diff --git a/vendor/github.com/Philipp15b/go-steam/LICENSE.txt b/vendor/github.com/Philipp15b/go-steam/LICENSE.txt new file mode 100644 index 00000000..8db7b81a --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/LICENSE.txt @@ -0,0 +1,26 @@ +Copyright (c) 2014 The go-steam Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * The names of its contributors may not be used to endorse or promote +products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/vendor/github.com/Philipp15b/go-steam/auth.go b/vendor/github.com/Philipp15b/go-steam/auth.go new file mode 100644 index 00000000..b67de335 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/auth.go @@ -0,0 +1,178 @@ +package steam + +import ( + "crypto/sha1" + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" + "github.com/golang/protobuf/proto" + "sync/atomic" + "time" +) + +type Auth struct { + client *Client + details *LogOnDetails +} + +type SentryHash []byte + +type LogOnDetails struct { + Username string + Password string + AuthCode string + TwoFactorCode string + SentryFileHash SentryHash +} + +// Log on with the given details. You must always specify username and +// password. For the first login, don't set an authcode or a hash and you'll receive an error +// and Steam will send you an authcode. Then you have to login again, this time with the authcode. +// Shortly after logging in, you'll receive a MachineAuthUpdateEvent with a hash which allows +// you to login without using an authcode in the future. +// +// If you don't use Steam Guard, username and password are enough. +func (a *Auth) LogOn(details *LogOnDetails) { + if len(details.Username) == 0 || len(details.Password) == 0 { + panic("Username and password must be set!") + } + + logon := new(CMsgClientLogon) + logon.AccountName = &details.Username + logon.Password = &details.Password + if details.AuthCode != "" { + logon.AuthCode = proto.String(details.AuthCode) + } + if details.TwoFactorCode != "" { + logon.TwoFactorCode = proto.String(details.TwoFactorCode) + } + logon.ClientLanguage = proto.String("english") + logon.ProtocolVersion = proto.Uint32(MsgClientLogon_CurrentProtocol) + logon.ShaSentryfile = details.SentryFileHash + + atomic.StoreUint64(&a.client.steamId, uint64(NewIdAdv(0, 1, int32(EUniverse_Public), int32(EAccountType_Individual)))) + + a.client.Write(NewClientMsgProtobuf(EMsg_ClientLogon, logon)) +} + +func (a *Auth) HandlePacket(packet *Packet) { + switch packet.EMsg { + case EMsg_ClientLogOnResponse: + a.handleLogOnResponse(packet) + case EMsg_ClientNewLoginKey: + a.handleLoginKey(packet) + case EMsg_ClientSessionToken: + case EMsg_ClientLoggedOff: + a.handleLoggedOff(packet) + case EMsg_ClientUpdateMachineAuth: + a.handleUpdateMachineAuth(packet) + case EMsg_ClientAccountInfo: + a.handleAccountInfo(packet) + case EMsg_ClientWalletInfoUpdate: + case EMsg_ClientRequestWebAPIAuthenticateUserNonceResponse: + case EMsg_ClientMarketingMessageUpdate: + } +} + +func (a *Auth) handleLogOnResponse(packet *Packet) { + if !packet.IsProto { + a.client.Fatalf("Got non-proto logon response!") + return + } + + body := new(CMsgClientLogonResponse) + msg := packet.ReadProtoMsg(body) + + result := EResult(body.GetEresult()) + if result == EResult_OK { + atomic.StoreInt32(&a.client.sessionId, msg.Header.Proto.GetClientSessionid()) + atomic.StoreUint64(&a.client.steamId, msg.Header.Proto.GetSteamid()) + a.client.Web.webLoginKey = *body.WebapiAuthenticateUserNonce + + go a.client.heartbeatLoop(time.Duration(body.GetOutOfGameHeartbeatSeconds())) + + a.client.Emit(&LoggedOnEvent{ + Result: EResult(body.GetEresult()), + ExtendedResult: EResult(body.GetEresultExtended()), + OutOfGameSecsPerHeartbeat: body.GetOutOfGameHeartbeatSeconds(), + InGameSecsPerHeartbeat: body.GetInGameHeartbeatSeconds(), + PublicIp: body.GetPublicIp(), + ServerTime: body.GetRtime32ServerTime(), + AccountFlags: EAccountFlags(body.GetAccountFlags()), + ClientSteamId: SteamId(body.GetClientSuppliedSteamid()), + EmailDomain: body.GetEmailDomain(), + CellId: body.GetCellId(), + CellIdPingThreshold: body.GetCellIdPingThreshold(), + Steam2Ticket: body.GetSteam2Ticket(), + UsePics: body.GetUsePics(), + WebApiUserNonce: body.GetWebapiAuthenticateUserNonce(), + IpCountryCode: body.GetIpCountryCode(), + VanityUrl: body.GetVanityUrl(), + NumLoginFailuresToMigrate: body.GetCountLoginfailuresToMigrate(), + NumDisconnectsToMigrate: body.GetCountDisconnectsToMigrate(), + }) + } else if result == EResult_Fail || result == EResult_ServiceUnavailable || result == EResult_TryAnotherCM { + // some error on Steam's side, we'll get an EOF later + } else { + a.client.Emit(&LogOnFailedEvent{ + Result: EResult(body.GetEresult()), + }) + a.client.Disconnect() + } +} + +func (a *Auth) handleLoginKey(packet *Packet) { + body := new(CMsgClientNewLoginKey) + packet.ReadProtoMsg(body) + a.client.Write(NewClientMsgProtobuf(EMsg_ClientNewLoginKeyAccepted, &CMsgClientNewLoginKeyAccepted{ + UniqueId: proto.Uint32(body.GetUniqueId()), + })) + a.client.Emit(&LoginKeyEvent{ + UniqueId: body.GetUniqueId(), + LoginKey: body.GetLoginKey(), + }) +} + +func (a *Auth) handleLoggedOff(packet *Packet) { + result := EResult_Invalid + if packet.IsProto { + body := new(CMsgClientLoggedOff) + packet.ReadProtoMsg(body) + result = EResult(body.GetEresult()) + } else { + body := new(MsgClientLoggedOff) + packet.ReadClientMsg(body) + result = body.Result + } + a.client.Emit(&LoggedOffEvent{Result: result}) +} + +func (a *Auth) handleUpdateMachineAuth(packet *Packet) { + body := new(CMsgClientUpdateMachineAuth) + packet.ReadProtoMsg(body) + hash := sha1.New() + hash.Write(packet.Data) + sha := hash.Sum(nil) + + msg := NewClientMsgProtobuf(EMsg_ClientUpdateMachineAuthResponse, &CMsgClientUpdateMachineAuthResponse{ + ShaFile: sha, + }) + msg.SetTargetJobId(packet.SourceJobId) + a.client.Write(msg) + + a.client.Emit(&MachineAuthUpdateEvent{sha}) +} + +func (a *Auth) handleAccountInfo(packet *Packet) { + body := new(CMsgClientAccountInfo) + packet.ReadProtoMsg(body) + a.client.Emit(&AccountInfoEvent{ + PersonaName: body.GetPersonaName(), + Country: body.GetIpCountry(), + CountAuthedComputers: body.GetCountAuthedComputers(), + AccountFlags: EAccountFlags(body.GetAccountFlags()), + FacebookId: body.GetFacebookId(), + FacebookName: body.GetFacebookName(), + }) +} diff --git a/vendor/github.com/Philipp15b/go-steam/auth_events.go b/vendor/github.com/Philipp15b/go-steam/auth_events.go new file mode 100644 index 00000000..45ad0e08 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/auth_events.go @@ -0,0 +1,53 @@ +package steam + +import ( + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" +) + +type LoggedOnEvent struct { + Result EResult + ExtendedResult EResult + OutOfGameSecsPerHeartbeat int32 + InGameSecsPerHeartbeat int32 + PublicIp uint32 + ServerTime uint32 + AccountFlags EAccountFlags + ClientSteamId SteamId `json:",string"` + EmailDomain string + CellId uint32 + CellIdPingThreshold uint32 + Steam2Ticket []byte + UsePics bool + WebApiUserNonce string + IpCountryCode string + VanityUrl string + NumLoginFailuresToMigrate int32 + NumDisconnectsToMigrate int32 +} + +type LogOnFailedEvent struct { + Result EResult +} + +type LoginKeyEvent struct { + UniqueId uint32 + LoginKey string +} + +type LoggedOffEvent struct { + Result EResult +} + +type MachineAuthUpdateEvent struct { + Hash []byte +} + +type AccountInfoEvent struct { + PersonaName string + Country string + CountAuthedComputers int32 + AccountFlags EAccountFlags + FacebookId uint64 `json:",string"` + FacebookName string +} diff --git a/vendor/github.com/Philipp15b/go-steam/client.go b/vendor/github.com/Philipp15b/go-steam/client.go new file mode 100644 index 00000000..667ad354 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/client.go @@ -0,0 +1,383 @@ +package steam + +import ( + "bytes" + "compress/gzip" + "crypto/rand" + "encoding/binary" + "fmt" + "hash/crc32" + "io/ioutil" + "net" + "sync" + "sync/atomic" + "time" + + "github.com/Philipp15b/go-steam/cryptoutil" + "github.com/Philipp15b/go-steam/netutil" + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" +) + +// Represents a client to the Steam network. +// Always poll events from the channel returned by Events() or receiving messages will stop. +// All access, unless otherwise noted, should be threadsafe. +// +// When a FatalErrorEvent is emitted, the connection is automatically closed. The same client can be used to reconnect. +// Other errors don't have any effect. +type Client struct { + // these need to be 64 bit aligned for sync/atomic on 32bit + sessionId int32 + _ uint32 + steamId uint64 + currentJobId uint64 + + Auth *Auth + Social *Social + Web *Web + Notifications *Notifications + Trading *Trading + GC *GameCoordinator + + events chan interface{} + handlers []PacketHandler + handlersMutex sync.RWMutex + + tempSessionKey []byte + + ConnectionTimeout time.Duration + + mutex sync.RWMutex // guarding conn and writeChan + conn connection + writeChan chan IMsg + writeBuf *bytes.Buffer + heartbeat *time.Ticker +} + +type PacketHandler interface { + HandlePacket(*Packet) +} + +func NewClient() *Client { + client := &Client{ + events: make(chan interface{}, 3), + writeBuf: new(bytes.Buffer), + } + client.Auth = &Auth{client: client} + client.RegisterPacketHandler(client.Auth) + client.Social = newSocial(client) + client.RegisterPacketHandler(client.Social) + client.Web = &Web{client: client} + client.RegisterPacketHandler(client.Web) + client.Notifications = newNotifications(client) + client.RegisterPacketHandler(client.Notifications) + client.Trading = &Trading{client: client} + client.RegisterPacketHandler(client.Trading) + client.GC = newGC(client) + client.RegisterPacketHandler(client.GC) + return client +} + +// Get the event channel. By convention all events are pointers, except for errors. +// It is never closed. +func (c *Client) Events() <-chan interface{} { + return c.events +} + +func (c *Client) Emit(event interface{}) { + c.events <- event +} + +// Emits a FatalErrorEvent formatted with fmt.Errorf and disconnects. +func (c *Client) Fatalf(format string, a ...interface{}) { + c.Emit(FatalErrorEvent(fmt.Errorf(format, a...))) + c.Disconnect() +} + +// Emits an error formatted with fmt.Errorf. +func (c *Client) Errorf(format string, a ...interface{}) { + c.Emit(fmt.Errorf(format, a...)) +} + +// Registers a PacketHandler that receives all incoming packets. +func (c *Client) RegisterPacketHandler(handler PacketHandler) { + c.handlersMutex.Lock() + defer c.handlersMutex.Unlock() + c.handlers = append(c.handlers, handler) +} + +func (c *Client) GetNextJobId() JobId { + return JobId(atomic.AddUint64(&c.currentJobId, 1)) +} + +func (c *Client) SteamId() SteamId { + return SteamId(atomic.LoadUint64(&c.steamId)) +} + +func (c *Client) SessionId() int32 { + return atomic.LoadInt32(&c.sessionId) +} + +func (c *Client) Connected() bool { + c.mutex.RLock() + defer c.mutex.RUnlock() + return c.conn != nil +} + +// Connects to a random Steam server and returns its address. +// If this client is already connected, it is disconnected first. +// This method tries to use an address from the Steam Directory and falls +// back to the built-in server list if the Steam Directory can't be reached. +// If you want to connect to a specific server, use `ConnectTo`. +func (c *Client) Connect() *netutil.PortAddr { + var server *netutil.PortAddr + if steamDirectoryCache.IsInitialized() { + server = steamDirectoryCache.GetRandomCM() + } else { + server = GetRandomCM() + } + c.ConnectTo(server) + return server +} + +// Connects to a specific server. +// You may want to use one of the `GetRandom*CM()` functions in this package. +// If this client is already connected, it is disconnected first. +func (c *Client) ConnectTo(addr *netutil.PortAddr) { + c.ConnectToBind(addr, nil) +} + +// Connects to a specific server, and binds to a specified local IP +// If this client is already connected, it is disconnected first. +func (c *Client) ConnectToBind(addr *netutil.PortAddr, local *net.TCPAddr) { + c.Disconnect() + + conn, err := dialTCP(local, addr.ToTCPAddr()) + if err != nil { + c.Fatalf("Connect failed: %v", err) + return + } + c.conn = conn + c.writeChan = make(chan IMsg, 5) + + go c.readLoop() + go c.writeLoop() +} + +func (c *Client) Disconnect() { + c.mutex.Lock() + defer c.mutex.Unlock() + + if c.conn == nil { + return + } + + c.conn.Close() + c.conn = nil + if c.heartbeat != nil { + c.heartbeat.Stop() + } + close(c.writeChan) + c.Emit(&DisconnectedEvent{}) + +} + +// Adds a message to the send queue. Modifications to the given message after +// writing are not allowed (possible race conditions). +// +// Writes to this client when not connected are ignored. +func (c *Client) Write(msg IMsg) { + if cm, ok := msg.(IClientMsg); ok { + cm.SetSessionId(c.SessionId()) + cm.SetSteamId(c.SteamId()) + } + c.mutex.RLock() + defer c.mutex.RUnlock() + if c.conn == nil { + return + } + c.writeChan <- msg +} + +func (c *Client) readLoop() { + for { + // This *should* be atomic on most platforms, but the Go spec doesn't guarantee it + c.mutex.RLock() + conn := c.conn + c.mutex.RUnlock() + if conn == nil { + return + } + packet, err := conn.Read() + + if err != nil { + c.Fatalf("Error reading from the connection: %v", err) + return + } + c.handlePacket(packet) + } +} + +func (c *Client) writeLoop() { + for { + c.mutex.RLock() + conn := c.conn + c.mutex.RUnlock() + if conn == nil { + return + } + + msg, ok := <-c.writeChan + if !ok { + return + } + + err := msg.Serialize(c.writeBuf) + if err != nil { + c.writeBuf.Reset() + c.Fatalf("Error serializing message %v: %v", msg, err) + return + } + + err = conn.Write(c.writeBuf.Bytes()) + + c.writeBuf.Reset() + + if err != nil { + c.Fatalf("Error writing message %v: %v", msg, err) + return + } + } +} + +func (c *Client) heartbeatLoop(seconds time.Duration) { + if c.heartbeat != nil { + c.heartbeat.Stop() + } + c.heartbeat = time.NewTicker(seconds * time.Second) + for { + _, ok := <-c.heartbeat.C + if !ok { + break + } + c.Write(NewClientMsgProtobuf(EMsg_ClientHeartBeat, new(CMsgClientHeartBeat))) + } + c.heartbeat = nil +} + +func (c *Client) handlePacket(packet *Packet) { + switch packet.EMsg { + case EMsg_ChannelEncryptRequest: + c.handleChannelEncryptRequest(packet) + case EMsg_ChannelEncryptResult: + c.handleChannelEncryptResult(packet) + case EMsg_Multi: + c.handleMulti(packet) + case EMsg_ClientCMList: + c.handleClientCMList(packet) + } + + c.handlersMutex.RLock() + defer c.handlersMutex.RUnlock() + for _, handler := range c.handlers { + handler.HandlePacket(packet) + } +} + +func (c *Client) handleChannelEncryptRequest(packet *Packet) { + body := NewMsgChannelEncryptRequest() + packet.ReadMsg(body) + + if body.Universe != EUniverse_Public { + c.Fatalf("Invalid univserse %v!", body.Universe) + } + + c.tempSessionKey = make([]byte, 32) + rand.Read(c.tempSessionKey) + encryptedKey := cryptoutil.RSAEncrypt(GetPublicKey(EUniverse_Public), c.tempSessionKey) + + payload := new(bytes.Buffer) + payload.Write(encryptedKey) + binary.Write(payload, binary.LittleEndian, crc32.ChecksumIEEE(encryptedKey)) + payload.WriteByte(0) + payload.WriteByte(0) + payload.WriteByte(0) + payload.WriteByte(0) + + c.Write(NewMsg(NewMsgChannelEncryptResponse(), payload.Bytes())) +} + +func (c *Client) handleChannelEncryptResult(packet *Packet) { + body := NewMsgChannelEncryptResult() + packet.ReadMsg(body) + + if body.Result != EResult_OK { + c.Fatalf("Encryption failed: %v", body.Result) + return + } + c.conn.SetEncryptionKey(c.tempSessionKey) + c.tempSessionKey = nil + + c.Emit(&ConnectedEvent{}) +} + +func (c *Client) handleMulti(packet *Packet) { + body := new(CMsgMulti) + packet.ReadProtoMsg(body) + + payload := body.GetMessageBody() + + if body.GetSizeUnzipped() > 0 { + r, err := gzip.NewReader(bytes.NewReader(payload)) + if err != nil { + c.Errorf("handleMulti: Error while decompressing: %v", err) + return + } + + payload, err = ioutil.ReadAll(r) + if err != nil { + c.Errorf("handleMulti: Error while decompressing: %v", err) + return + } + } + + pr := bytes.NewReader(payload) + for pr.Len() > 0 { + var length uint32 + binary.Read(pr, binary.LittleEndian, &length) + packetData := make([]byte, length) + pr.Read(packetData) + p, err := NewPacket(packetData) + if err != nil { + c.Errorf("Error reading packet in Multi msg %v: %v", packet, err) + continue + } + c.handlePacket(p) + } +} + +func (c *Client) handleClientCMList(packet *Packet) { + body := new(CMsgClientCMList) + packet.ReadProtoMsg(body) + + l := make([]*netutil.PortAddr, 0) + for i, ip := range body.GetCmAddresses() { + l = append(l, &netutil.PortAddr{ + readIp(ip), + uint16(body.GetCmPorts()[i]), + }) + } + + c.Emit(&ClientCMListEvent{l}) +} + +func readIp(ip uint32) net.IP { + r := make(net.IP, 4) + r[3] = byte(ip) + r[2] = byte(ip >> 8) + r[1] = byte(ip >> 16) + r[0] = byte(ip >> 24) + return r +} diff --git a/vendor/github.com/Philipp15b/go-steam/client_events.go b/vendor/github.com/Philipp15b/go-steam/client_events.go new file mode 100644 index 00000000..c61689cb --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/client_events.go @@ -0,0 +1,20 @@ +package steam + +import ( + "github.com/Philipp15b/go-steam/netutil" +) + +// When this event is emitted by the Client, the connection is automatically closed. +// This may be caused by a network error, for example. +type FatalErrorEvent error + +type ConnectedEvent struct{} + +type DisconnectedEvent struct{} + +// A list of connection manager addresses to connect to in the future. +// You should always save them and then select one of these +// instead of the builtin ones for the next connection. +type ClientCMListEvent struct { + Addresses []*netutil.PortAddr +} diff --git a/vendor/github.com/Philipp15b/go-steam/community/community.go b/vendor/github.com/Philipp15b/go-steam/community/community.go new file mode 100644 index 00000000..641c3942 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/community/community.go @@ -0,0 +1,35 @@ +package community + +import ( + "net/http" + "net/http/cookiejar" + "net/url" +) + +const cookiePath = "https://steamcommunity.com/" + +func SetCookies(client *http.Client, sessionId, steamLogin, steamLoginSecure string) { + if client.Jar == nil { + client.Jar, _ = cookiejar.New(new(cookiejar.Options)) + } + base, err := url.Parse(cookiePath) + if err != nil { + panic(err) + } + client.Jar.SetCookies(base, []*http.Cookie{ + // It seems that, for some reason, Steam tries to URL-decode the cookie. + &http.Cookie{ + Name: "sessionid", + Value: url.QueryEscape(sessionId), + }, + // steamLogin is already URL-encoded. + &http.Cookie{ + Name: "steamLogin", + Value: steamLogin, + }, + &http.Cookie{ + Name: "steamLoginSecure", + Value: steamLoginSecure, + }, + }) +} diff --git a/vendor/github.com/Philipp15b/go-steam/connection.go b/vendor/github.com/Philipp15b/go-steam/connection.go new file mode 100644 index 00000000..0036e40f --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/connection.go @@ -0,0 +1,127 @@ +package steam + +import ( + "crypto/aes" + "crypto/cipher" + "encoding/binary" + "fmt" + "io" + "net" + "sync" + + "github.com/Philipp15b/go-steam/cryptoutil" + . "github.com/Philipp15b/go-steam/protocol" +) + +type connection interface { + Read() (*Packet, error) + Write([]byte) error + Close() error + SetEncryptionKey([]byte) + IsEncrypted() bool +} + +const tcpConnectionMagic uint32 = 0x31305456 // "VT01" + +type tcpConnection struct { + conn *net.TCPConn + ciph cipher.Block + cipherMutex sync.RWMutex +} + +func dialTCP(laddr, raddr *net.TCPAddr) (*tcpConnection, error) { + conn, err := net.DialTCP("tcp", laddr, raddr) + if err != nil { + return nil, err + } + + return &tcpConnection{ + conn: conn, + }, nil +} + +func (c *tcpConnection) Read() (*Packet, error) { + // All packets begin with a packet length + var packetLen uint32 + err := binary.Read(c.conn, binary.LittleEndian, &packetLen) + if err != nil { + return nil, err + } + + // A magic value follows for validation + var packetMagic uint32 + err = binary.Read(c.conn, binary.LittleEndian, &packetMagic) + if err != nil { + return nil, err + } + if packetMagic != tcpConnectionMagic { + return nil, fmt.Errorf("Invalid connection magic! Expected %d, got %d!", tcpConnectionMagic, packetMagic) + } + + buf := make([]byte, packetLen, packetLen) + _, err = io.ReadFull(c.conn, buf) + if err == io.ErrUnexpectedEOF { + return nil, io.EOF + } + if err != nil { + return nil, err + } + + // Packets after ChannelEncryptResult are encrypted + c.cipherMutex.RLock() + if c.ciph != nil { + buf = cryptoutil.SymmetricDecrypt(c.ciph, buf) + } + c.cipherMutex.RUnlock() + + return NewPacket(buf) +} + +// Writes a message. This may only be used by one goroutine at a time. +func (c *tcpConnection) Write(message []byte) error { + c.cipherMutex.RLock() + if c.ciph != nil { + message = cryptoutil.SymmetricEncrypt(c.ciph, message) + } + c.cipherMutex.RUnlock() + + err := binary.Write(c.conn, binary.LittleEndian, uint32(len(message))) + if err != nil { + return err + } + err = binary.Write(c.conn, binary.LittleEndian, tcpConnectionMagic) + if err != nil { + return err + } + + _, err = c.conn.Write(message) + return err +} + +func (c *tcpConnection) Close() error { + return c.conn.Close() +} + +func (c *tcpConnection) SetEncryptionKey(key []byte) { + c.cipherMutex.Lock() + defer c.cipherMutex.Unlock() + if key == nil { + c.ciph = nil + return + } + if len(key) != 32 { + panic("Connection AES key is not 32 bytes long!") + } + + var err error + c.ciph, err = aes.NewCipher(key) + if err != nil { + panic(err) + } +} + +func (c *tcpConnection) IsEncrypted() bool { + c.cipherMutex.RLock() + defer c.cipherMutex.RUnlock() + return c.ciph != nil +} diff --git a/vendor/github.com/Philipp15b/go-steam/cryptoutil/cryptoutil.go b/vendor/github.com/Philipp15b/go-steam/cryptoutil/cryptoutil.go new file mode 100644 index 00000000..b44f8d26 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/cryptoutil/cryptoutil.go @@ -0,0 +1,38 @@ +package cryptoutil + +import ( + "crypto/aes" + "crypto/cipher" + "crypto/rand" +) + +// Performs an encryption using AES/CBC/PKCS7 +// with a random IV prepended using AES/ECB/None. +func SymmetricEncrypt(ciph cipher.Block, src []byte) []byte { + // get a random IV and ECB encrypt it + iv := make([]byte, aes.BlockSize, aes.BlockSize) + _, err := rand.Read(iv) + if err != nil { + panic(err) + } + encryptedIv := make([]byte, aes.BlockSize, aes.BlockSize) + newECBEncrypter(ciph).CryptBlocks(encryptedIv, iv) + + // pad it, copy the IV to the first 16 bytes and encrypt the rest with CBC + encrypted := padPKCS7WithIV(src) + copy(encrypted, encryptedIv) + cipher.NewCBCEncrypter(ciph, iv).CryptBlocks(encrypted[aes.BlockSize:], encrypted[aes.BlockSize:]) + return encrypted +} + +// Decrypts data from the reader using AES/CBC/PKCS7 with an IV +// prepended using AES/ECB/None. The src slice may not be used anymore. +func SymmetricDecrypt(ciph cipher.Block, src []byte) []byte { + iv := src[:aes.BlockSize] + newECBDecrypter(ciph).CryptBlocks(iv, iv) + + data := src[aes.BlockSize:] + cipher.NewCBCDecrypter(ciph, iv).CryptBlocks(data, data) + + return unpadPKCS7(data) +} diff --git a/vendor/github.com/Philipp15b/go-steam/cryptoutil/ecb.go b/vendor/github.com/Philipp15b/go-steam/cryptoutil/ecb.go new file mode 100644 index 00000000..4298686f --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/cryptoutil/ecb.go @@ -0,0 +1,68 @@ +package cryptoutil + +import ( + "crypto/cipher" +) + +// From this code review: https://codereview.appspot.com/7860047/ +// by fasmat for the Go crypto/cipher package + +type ecb struct { + b cipher.Block + blockSize int +} + +func newECB(b cipher.Block) *ecb { + return &ecb{ + b: b, + blockSize: b.BlockSize(), + } +} + +type ecbEncrypter ecb + +// NewECBEncrypter returns a BlockMode which encrypts in electronic code book +// mode, using the given Block. +func newECBEncrypter(b cipher.Block) cipher.BlockMode { + return (*ecbEncrypter)(newECB(b)) +} + +func (x *ecbEncrypter) BlockSize() int { return x.blockSize } + +func (x *ecbEncrypter) CryptBlocks(dst, src []byte) { + if len(src)%x.blockSize != 0 { + panic("cryptoutil/ecb: input not full blocks") + } + if len(dst) < len(src) { + panic("cryptoutil/ecb: output smaller than input") + } + for len(src) > 0 { + x.b.Encrypt(dst, src[:x.blockSize]) + src = src[x.blockSize:] + dst = dst[x.blockSize:] + } +} + +type ecbDecrypter ecb + +// newECBDecrypter returns a BlockMode which decrypts in electronic code book +// mode, using the given Block. +func newECBDecrypter(b cipher.Block) cipher.BlockMode { + return (*ecbDecrypter)(newECB(b)) +} + +func (x *ecbDecrypter) BlockSize() int { return x.blockSize } + +func (x *ecbDecrypter) CryptBlocks(dst, src []byte) { + if len(src)%x.blockSize != 0 { + panic("cryptoutil/ecb: input not full blocks") + } + if len(dst) < len(src) { + panic("cryptoutil/ecb: output smaller than input") + } + for len(src) > 0 { + x.b.Decrypt(dst, src[:x.blockSize]) + src = src[x.blockSize:] + dst = dst[x.blockSize:] + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/cryptoutil/pkcs7.go b/vendor/github.com/Philipp15b/go-steam/cryptoutil/pkcs7.go new file mode 100644 index 00000000..8200fb94 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/cryptoutil/pkcs7.go @@ -0,0 +1,25 @@ +package cryptoutil + +import ( + "crypto/aes" +) + +// Returns a new byte array padded with PKCS7 and prepended +// with empty space of the AES block size (16 bytes) for the IV. +func padPKCS7WithIV(src []byte) []byte { + missing := aes.BlockSize - (len(src) % aes.BlockSize) + newSize := len(src) + aes.BlockSize + missing + dest := make([]byte, newSize, newSize) + copy(dest[aes.BlockSize:], src) + + padding := byte(missing) + for i := newSize - missing; i < newSize; i++ { + dest[i] = padding + } + return dest +} + +func unpadPKCS7(src []byte) []byte { + padLen := src[len(src)-1] + return src[:len(src)-int(padLen)] +} diff --git a/vendor/github.com/Philipp15b/go-steam/cryptoutil/rsa.go b/vendor/github.com/Philipp15b/go-steam/cryptoutil/rsa.go new file mode 100644 index 00000000..78cd954a --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/cryptoutil/rsa.go @@ -0,0 +1,31 @@ +package cryptoutil + +import ( + "crypto/rand" + "crypto/rsa" + "crypto/sha1" + "crypto/x509" + "errors" +) + +// Parses a DER encoded RSA public key +func ParseASN1RSAPublicKey(derBytes []byte) (*rsa.PublicKey, error) { + key, err := x509.ParsePKIXPublicKey(derBytes) + if err != nil { + return nil, err + } + pubKey, ok := key.(*rsa.PublicKey) + if !ok { + return nil, errors.New("not an RSA public key") + } + return pubKey, nil +} + +// Encrypts a message with the given public key using RSA-OAEP and the sha1 hash function. +func RSAEncrypt(pub *rsa.PublicKey, msg []byte) []byte { + b, err := rsa.EncryptOAEP(sha1.New(), rand.Reader, pub, msg, nil) + if err != nil { + panic(err) + } + return b +} diff --git a/vendor/github.com/Philipp15b/go-steam/doc.go b/vendor/github.com/Philipp15b/go-steam/doc.go new file mode 100644 index 00000000..4d695037 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/doc.go @@ -0,0 +1,53 @@ +/* +This package allows you to automate actions on Valve's Steam network. It is a Go port of SteamKit. + +To login, you'll have to create a new Client first. Then connect to the Steam network +and wait for a ConnectedCallback. Then you may call the Login method in the Auth module +with your login information. This is covered in more detail in the method's documentation. After you've +received the LoggedOnEvent, you should set your persona state to online to receive friend lists etc. + +Example code + +You can also find a running example in the `gsbot` package. + + package main + + import ( + "io/ioutil" + "log" + + "github.com/Philipp15b/go-steam" + "github.com/Philipp15b/go-steam/protocol/steamlang" + ) + + func main() { + myLoginInfo := new(steam.LogOnDetails) + myLoginInfo.Username = "Your username" + myLoginInfo.Password = "Your password" + + client := steam.NewClient() + client.Connect() + for event := range client.Events() { + switch e := event.(type) { + case *steam.ConnectedEvent: + client.Auth.LogOn(myLoginInfo) + case *steam.MachineAuthUpdateEvent: + ioutil.WriteFile("sentry", e.Hash, 0666) + case *steam.LoggedOnEvent: + client.Social.SetPersonaState(steamlang.EPersonaState_Online) + case steam.FatalErrorEvent: + log.Print(e) + case error: + log.Print(e) + } + } + } + + +Events + +go-steam emits events that can be read via Client.Events(). Although the channel has the type interface{}, +only types from this package ending with "Event" and errors will be emitted. + +*/ +package steam diff --git a/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/base.pb.go b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/base.pb.go new file mode 100644 index 00000000..302e667c --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/base.pb.go @@ -0,0 +1,3651 @@ +// Code generated by protoc-gen-go. +// source: base_gcmessages.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 protobuf is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type EGCBaseMsg int32 + +const ( + EGCBaseMsg_k_EMsgGCSystemMessage EGCBaseMsg = 4001 + EGCBaseMsg_k_EMsgGCReplicateConVars EGCBaseMsg = 4002 + EGCBaseMsg_k_EMsgGCConVarUpdated EGCBaseMsg = 4003 + EGCBaseMsg_k_EMsgGCInviteToParty EGCBaseMsg = 4501 + EGCBaseMsg_k_EMsgGCInvitationCreated EGCBaseMsg = 4502 + EGCBaseMsg_k_EMsgGCPartyInviteResponse EGCBaseMsg = 4503 + EGCBaseMsg_k_EMsgGCKickFromParty EGCBaseMsg = 4504 + EGCBaseMsg_k_EMsgGCLeaveParty EGCBaseMsg = 4505 + EGCBaseMsg_k_EMsgGCServerAvailable EGCBaseMsg = 4506 + EGCBaseMsg_k_EMsgGCClientConnectToServer EGCBaseMsg = 4507 + EGCBaseMsg_k_EMsgGCGameServerInfo EGCBaseMsg = 4508 + EGCBaseMsg_k_EMsgGCError EGCBaseMsg = 4509 + EGCBaseMsg_k_EMsgGCReplay_UploadedToYouTube EGCBaseMsg = 4510 + EGCBaseMsg_k_EMsgGCLANServerAvailable EGCBaseMsg = 4511 + EGCBaseMsg_k_EMsgGCInviteToLobby EGCBaseMsg = 4512 + EGCBaseMsg_k_EMsgGCLobbyInviteResponse EGCBaseMsg = 4513 +) + +var EGCBaseMsg_name = map[int32]string{ + 4001: "k_EMsgGCSystemMessage", + 4002: "k_EMsgGCReplicateConVars", + 4003: "k_EMsgGCConVarUpdated", + 4501: "k_EMsgGCInviteToParty", + 4502: "k_EMsgGCInvitationCreated", + 4503: "k_EMsgGCPartyInviteResponse", + 4504: "k_EMsgGCKickFromParty", + 4505: "k_EMsgGCLeaveParty", + 4506: "k_EMsgGCServerAvailable", + 4507: "k_EMsgGCClientConnectToServer", + 4508: "k_EMsgGCGameServerInfo", + 4509: "k_EMsgGCError", + 4510: "k_EMsgGCReplay_UploadedToYouTube", + 4511: "k_EMsgGCLANServerAvailable", + 4512: "k_EMsgGCInviteToLobby", + 4513: "k_EMsgGCLobbyInviteResponse", +} +var EGCBaseMsg_value = map[string]int32{ + "k_EMsgGCSystemMessage": 4001, + "k_EMsgGCReplicateConVars": 4002, + "k_EMsgGCConVarUpdated": 4003, + "k_EMsgGCInviteToParty": 4501, + "k_EMsgGCInvitationCreated": 4502, + "k_EMsgGCPartyInviteResponse": 4503, + "k_EMsgGCKickFromParty": 4504, + "k_EMsgGCLeaveParty": 4505, + "k_EMsgGCServerAvailable": 4506, + "k_EMsgGCClientConnectToServer": 4507, + "k_EMsgGCGameServerInfo": 4508, + "k_EMsgGCError": 4509, + "k_EMsgGCReplay_UploadedToYouTube": 4510, + "k_EMsgGCLANServerAvailable": 4511, + "k_EMsgGCInviteToLobby": 4512, + "k_EMsgGCLobbyInviteResponse": 4513, +} + +func (x EGCBaseMsg) Enum() *EGCBaseMsg { + p := new(EGCBaseMsg) + *p = x + return p +} +func (x EGCBaseMsg) String() string { + return proto.EnumName(EGCBaseMsg_name, int32(x)) +} +func (x *EGCBaseMsg) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCBaseMsg_value, data, "EGCBaseMsg") + if err != nil { + return err + } + *x = EGCBaseMsg(value) + return nil +} +func (EGCBaseMsg) EnumDescriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} } + +type EGCBaseProtoObjectTypes int32 + +const ( + EGCBaseProtoObjectTypes_k_EProtoObjectPartyInvite EGCBaseProtoObjectTypes = 1001 + EGCBaseProtoObjectTypes_k_EProtoObjectLobbyInvite EGCBaseProtoObjectTypes = 1002 +) + +var EGCBaseProtoObjectTypes_name = map[int32]string{ + 1001: "k_EProtoObjectPartyInvite", + 1002: "k_EProtoObjectLobbyInvite", +} +var EGCBaseProtoObjectTypes_value = map[string]int32{ + "k_EProtoObjectPartyInvite": 1001, + "k_EProtoObjectLobbyInvite": 1002, +} + +func (x EGCBaseProtoObjectTypes) Enum() *EGCBaseProtoObjectTypes { + p := new(EGCBaseProtoObjectTypes) + *p = x + return p +} +func (x EGCBaseProtoObjectTypes) String() string { + return proto.EnumName(EGCBaseProtoObjectTypes_name, int32(x)) +} +func (x *EGCBaseProtoObjectTypes) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCBaseProtoObjectTypes_value, data, "EGCBaseProtoObjectTypes") + if err != nil { + return err + } + *x = EGCBaseProtoObjectTypes(value) + return nil +} +func (EGCBaseProtoObjectTypes) EnumDescriptor() ([]byte, []int) { return base_fileDescriptor0, []int{1} } + +type ECustomGameInstallStatus int32 + +const ( + ECustomGameInstallStatus_k_ECustomGameInstallStatus_Unknown ECustomGameInstallStatus = 0 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_Ready ECustomGameInstallStatus = 1 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_Busy ECustomGameInstallStatus = 2 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_FailedGeneric ECustomGameInstallStatus = 101 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_FailedInternalError ECustomGameInstallStatus = 102 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_RequestedTimestampTooOld ECustomGameInstallStatus = 103 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_RequestedTimestampTooNew ECustomGameInstallStatus = 104 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_CRCMismatch ECustomGameInstallStatus = 105 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_FailedSteam ECustomGameInstallStatus = 106 + ECustomGameInstallStatus_k_ECustomGameInstallStatus_FailedCanceled ECustomGameInstallStatus = 107 +) + +var ECustomGameInstallStatus_name = map[int32]string{ + 0: "k_ECustomGameInstallStatus_Unknown", + 1: "k_ECustomGameInstallStatus_Ready", + 2: "k_ECustomGameInstallStatus_Busy", + 101: "k_ECustomGameInstallStatus_FailedGeneric", + 102: "k_ECustomGameInstallStatus_FailedInternalError", + 103: "k_ECustomGameInstallStatus_RequestedTimestampTooOld", + 104: "k_ECustomGameInstallStatus_RequestedTimestampTooNew", + 105: "k_ECustomGameInstallStatus_CRCMismatch", + 106: "k_ECustomGameInstallStatus_FailedSteam", + 107: "k_ECustomGameInstallStatus_FailedCanceled", +} +var ECustomGameInstallStatus_value = map[string]int32{ + "k_ECustomGameInstallStatus_Unknown": 0, + "k_ECustomGameInstallStatus_Ready": 1, + "k_ECustomGameInstallStatus_Busy": 2, + "k_ECustomGameInstallStatus_FailedGeneric": 101, + "k_ECustomGameInstallStatus_FailedInternalError": 102, + "k_ECustomGameInstallStatus_RequestedTimestampTooOld": 103, + "k_ECustomGameInstallStatus_RequestedTimestampTooNew": 104, + "k_ECustomGameInstallStatus_CRCMismatch": 105, + "k_ECustomGameInstallStatus_FailedSteam": 106, + "k_ECustomGameInstallStatus_FailedCanceled": 107, +} + +func (x ECustomGameInstallStatus) Enum() *ECustomGameInstallStatus { + p := new(ECustomGameInstallStatus) + *p = x + return p +} +func (x ECustomGameInstallStatus) String() string { + return proto.EnumName(ECustomGameInstallStatus_name, int32(x)) +} +func (x *ECustomGameInstallStatus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ECustomGameInstallStatus_value, data, "ECustomGameInstallStatus") + if err != nil { + return err + } + *x = ECustomGameInstallStatus(value) + return nil +} +func (ECustomGameInstallStatus) EnumDescriptor() ([]byte, []int) { return base_fileDescriptor0, []int{2} } + +type GC_BannedWordType int32 + +const ( + GC_BannedWordType_GC_BANNED_WORD_DISABLE_WORD GC_BannedWordType = 0 + GC_BannedWordType_GC_BANNED_WORD_ENABLE_WORD GC_BannedWordType = 1 +) + +var GC_BannedWordType_name = map[int32]string{ + 0: "GC_BANNED_WORD_DISABLE_WORD", + 1: "GC_BANNED_WORD_ENABLE_WORD", +} +var GC_BannedWordType_value = map[string]int32{ + "GC_BANNED_WORD_DISABLE_WORD": 0, + "GC_BANNED_WORD_ENABLE_WORD": 1, +} + +func (x GC_BannedWordType) Enum() *GC_BannedWordType { + p := new(GC_BannedWordType) + *p = x + return p +} +func (x GC_BannedWordType) String() string { + return proto.EnumName(GC_BannedWordType_name, int32(x)) +} +func (x *GC_BannedWordType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GC_BannedWordType_value, data, "GC_BannedWordType") + if err != nil { + return err + } + *x = GC_BannedWordType(value) + return nil +} +func (GC_BannedWordType) EnumDescriptor() ([]byte, []int) { return base_fileDescriptor0, []int{3} } + +type CMsgExtractGemsResponse_EExtractGems int32 + +const ( + CMsgExtractGemsResponse_k_ExtractGems_Succeeded CMsgExtractGemsResponse_EExtractGems = 0 + CMsgExtractGemsResponse_k_ExtractGems_Failed_ToolIsInvalid CMsgExtractGemsResponse_EExtractGems = 1 + CMsgExtractGemsResponse_k_ExtractGems_Failed_ItemIsInvalid CMsgExtractGemsResponse_EExtractGems = 2 + CMsgExtractGemsResponse_k_ExtractGems_Failed_ToolCannotRemoveGem CMsgExtractGemsResponse_EExtractGems = 3 + CMsgExtractGemsResponse_k_ExtractGems_Failed_FailedToRemoveGem CMsgExtractGemsResponse_EExtractGems = 4 +) + +var CMsgExtractGemsResponse_EExtractGems_name = map[int32]string{ + 0: "k_ExtractGems_Succeeded", + 1: "k_ExtractGems_Failed_ToolIsInvalid", + 2: "k_ExtractGems_Failed_ItemIsInvalid", + 3: "k_ExtractGems_Failed_ToolCannotRemoveGem", + 4: "k_ExtractGems_Failed_FailedToRemoveGem", +} +var CMsgExtractGemsResponse_EExtractGems_value = map[string]int32{ + "k_ExtractGems_Succeeded": 0, + "k_ExtractGems_Failed_ToolIsInvalid": 1, + "k_ExtractGems_Failed_ItemIsInvalid": 2, + "k_ExtractGems_Failed_ToolCannotRemoveGem": 3, + "k_ExtractGems_Failed_FailedToRemoveGem": 4, +} + +func (x CMsgExtractGemsResponse_EExtractGems) Enum() *CMsgExtractGemsResponse_EExtractGems { + p := new(CMsgExtractGemsResponse_EExtractGems) + *p = x + return p +} +func (x CMsgExtractGemsResponse_EExtractGems) String() string { + return proto.EnumName(CMsgExtractGemsResponse_EExtractGems_name, int32(x)) +} +func (x *CMsgExtractGemsResponse_EExtractGems) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgExtractGemsResponse_EExtractGems_value, data, "CMsgExtractGemsResponse_EExtractGems") + if err != nil { + return err + } + *x = CMsgExtractGemsResponse_EExtractGems(value) + return nil +} +func (CMsgExtractGemsResponse_EExtractGems) EnumDescriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{78, 0} +} + +type CMsgAddSocketResponse_EAddSocket int32 + +const ( + CMsgAddSocketResponse_k_AddSocket_Succeeded CMsgAddSocketResponse_EAddSocket = 0 + CMsgAddSocketResponse_k_AddSocket_Failed_ToolIsInvalid CMsgAddSocketResponse_EAddSocket = 1 + CMsgAddSocketResponse_k_AddSocket_Failed_ItemCannotBeSocketed CMsgAddSocketResponse_EAddSocket = 2 + CMsgAddSocketResponse_k_AddSocket_Failed_FailedToAddSocket CMsgAddSocketResponse_EAddSocket = 3 +) + +var CMsgAddSocketResponse_EAddSocket_name = map[int32]string{ + 0: "k_AddSocket_Succeeded", + 1: "k_AddSocket_Failed_ToolIsInvalid", + 2: "k_AddSocket_Failed_ItemCannotBeSocketed", + 3: "k_AddSocket_Failed_FailedToAddSocket", +} +var CMsgAddSocketResponse_EAddSocket_value = map[string]int32{ + "k_AddSocket_Succeeded": 0, + "k_AddSocket_Failed_ToolIsInvalid": 1, + "k_AddSocket_Failed_ItemCannotBeSocketed": 2, + "k_AddSocket_Failed_FailedToAddSocket": 3, +} + +func (x CMsgAddSocketResponse_EAddSocket) Enum() *CMsgAddSocketResponse_EAddSocket { + p := new(CMsgAddSocketResponse_EAddSocket) + *p = x + return p +} +func (x CMsgAddSocketResponse_EAddSocket) String() string { + return proto.EnumName(CMsgAddSocketResponse_EAddSocket_name, int32(x)) +} +func (x *CMsgAddSocketResponse_EAddSocket) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgAddSocketResponse_EAddSocket_value, data, "CMsgAddSocketResponse_EAddSocket") + if err != nil { + return err + } + *x = CMsgAddSocketResponse_EAddSocket(value) + return nil +} +func (CMsgAddSocketResponse_EAddSocket) EnumDescriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{80, 0} +} + +type CMsgAddItemToSocketResponse_EAddGem int32 + +const ( + CMsgAddItemToSocketResponse_k_AddGem_Succeeded CMsgAddItemToSocketResponse_EAddGem = 0 + CMsgAddItemToSocketResponse_k_AddGem_Failed_GemIsInvalid CMsgAddItemToSocketResponse_EAddGem = 1 + CMsgAddItemToSocketResponse_k_AddGem_Failed_ItemIsInvalid CMsgAddItemToSocketResponse_EAddGem = 2 + CMsgAddItemToSocketResponse_k_AddGem_Failed_FailedToAddGem CMsgAddItemToSocketResponse_EAddGem = 3 + CMsgAddItemToSocketResponse_k_AddGem_Failed_InvalidGemTypeForSocket CMsgAddItemToSocketResponse_EAddGem = 4 + CMsgAddItemToSocketResponse_k_AddGem_Failed_InvalidGemTypeForHero CMsgAddItemToSocketResponse_EAddGem = 5 + CMsgAddItemToSocketResponse_k_AddGem_Failed_InvalidGemTypeForSlot CMsgAddItemToSocketResponse_EAddGem = 6 + CMsgAddItemToSocketResponse_k_AddGem_Failed_SocketContainsUnremovableGem CMsgAddItemToSocketResponse_EAddGem = 7 +) + +var CMsgAddItemToSocketResponse_EAddGem_name = map[int32]string{ + 0: "k_AddGem_Succeeded", + 1: "k_AddGem_Failed_GemIsInvalid", + 2: "k_AddGem_Failed_ItemIsInvalid", + 3: "k_AddGem_Failed_FailedToAddGem", + 4: "k_AddGem_Failed_InvalidGemTypeForSocket", + 5: "k_AddGem_Failed_InvalidGemTypeForHero", + 6: "k_AddGem_Failed_InvalidGemTypeForSlot", + 7: "k_AddGem_Failed_SocketContainsUnremovableGem", +} +var CMsgAddItemToSocketResponse_EAddGem_value = map[string]int32{ + "k_AddGem_Succeeded": 0, + "k_AddGem_Failed_GemIsInvalid": 1, + "k_AddGem_Failed_ItemIsInvalid": 2, + "k_AddGem_Failed_FailedToAddGem": 3, + "k_AddGem_Failed_InvalidGemTypeForSocket": 4, + "k_AddGem_Failed_InvalidGemTypeForHero": 5, + "k_AddGem_Failed_InvalidGemTypeForSlot": 6, + "k_AddGem_Failed_SocketContainsUnremovableGem": 7, +} + +func (x CMsgAddItemToSocketResponse_EAddGem) Enum() *CMsgAddItemToSocketResponse_EAddGem { + p := new(CMsgAddItemToSocketResponse_EAddGem) + *p = x + return p +} +func (x CMsgAddItemToSocketResponse_EAddGem) String() string { + return proto.EnumName(CMsgAddItemToSocketResponse_EAddGem_name, int32(x)) +} +func (x *CMsgAddItemToSocketResponse_EAddGem) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgAddItemToSocketResponse_EAddGem_value, data, "CMsgAddItemToSocketResponse_EAddGem") + if err != nil { + return err + } + *x = CMsgAddItemToSocketResponse_EAddGem(value) + return nil +} +func (CMsgAddItemToSocketResponse_EAddGem) EnumDescriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{83, 0} +} + +type CMsgResetStrangeGemCountResponse_EResetGem int32 + +const ( + CMsgResetStrangeGemCountResponse_k_ResetGem_Succeeded CMsgResetStrangeGemCountResponse_EResetGem = 0 + CMsgResetStrangeGemCountResponse_k_ResetGem_Failed_FailedToResetGem CMsgResetStrangeGemCountResponse_EResetGem = 1 + CMsgResetStrangeGemCountResponse_k_ResetGem_Failed_ItemIsInvalid CMsgResetStrangeGemCountResponse_EResetGem = 2 + CMsgResetStrangeGemCountResponse_k_ResetGem_Failed_InvalidSocketId CMsgResetStrangeGemCountResponse_EResetGem = 3 + CMsgResetStrangeGemCountResponse_k_ResetGem_Failed_SocketCannotBeReset CMsgResetStrangeGemCountResponse_EResetGem = 4 +) + +var CMsgResetStrangeGemCountResponse_EResetGem_name = map[int32]string{ + 0: "k_ResetGem_Succeeded", + 1: "k_ResetGem_Failed_FailedToResetGem", + 2: "k_ResetGem_Failed_ItemIsInvalid", + 3: "k_ResetGem_Failed_InvalidSocketId", + 4: "k_ResetGem_Failed_SocketCannotBeReset", +} +var CMsgResetStrangeGemCountResponse_EResetGem_value = map[string]int32{ + "k_ResetGem_Succeeded": 0, + "k_ResetGem_Failed_FailedToResetGem": 1, + "k_ResetGem_Failed_ItemIsInvalid": 2, + "k_ResetGem_Failed_InvalidSocketId": 3, + "k_ResetGem_Failed_SocketCannotBeReset": 4, +} + +func (x CMsgResetStrangeGemCountResponse_EResetGem) Enum() *CMsgResetStrangeGemCountResponse_EResetGem { + p := new(CMsgResetStrangeGemCountResponse_EResetGem) + *p = x + return p +} +func (x CMsgResetStrangeGemCountResponse_EResetGem) String() string { + return proto.EnumName(CMsgResetStrangeGemCountResponse_EResetGem_name, int32(x)) +} +func (x *CMsgResetStrangeGemCountResponse_EResetGem) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgResetStrangeGemCountResponse_EResetGem_value, data, "CMsgResetStrangeGemCountResponse_EResetGem") + if err != nil { + return err + } + *x = CMsgResetStrangeGemCountResponse_EResetGem(value) + return nil +} +func (CMsgResetStrangeGemCountResponse_EResetGem) EnumDescriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{85, 0} +} + +type CGCStorePurchaseInit_LineItem struct { + ItemDefId *uint32 `protobuf:"varint,1,opt,name=item_def_id" json:"item_def_id,omitempty"` + Quantity *uint32 `protobuf:"varint,2,opt,name=quantity" json:"quantity,omitempty"` + CostInLocalCurrency *uint32 `protobuf:"varint,3,opt,name=cost_in_local_currency" json:"cost_in_local_currency,omitempty"` + PurchaseType *uint32 `protobuf:"varint,4,opt,name=purchase_type" json:"purchase_type,omitempty"` + SourceReferenceId *uint64 `protobuf:"varint,5,opt,name=source_reference_id" json:"source_reference_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCStorePurchaseInit_LineItem) Reset() { *m = CGCStorePurchaseInit_LineItem{} } +func (m *CGCStorePurchaseInit_LineItem) String() string { return proto.CompactTextString(m) } +func (*CGCStorePurchaseInit_LineItem) ProtoMessage() {} +func (*CGCStorePurchaseInit_LineItem) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} } + +func (m *CGCStorePurchaseInit_LineItem) GetItemDefId() uint32 { + if m != nil && m.ItemDefId != nil { + return *m.ItemDefId + } + return 0 +} + +func (m *CGCStorePurchaseInit_LineItem) GetQuantity() uint32 { + if m != nil && m.Quantity != nil { + return *m.Quantity + } + return 0 +} + +func (m *CGCStorePurchaseInit_LineItem) GetCostInLocalCurrency() uint32 { + if m != nil && m.CostInLocalCurrency != nil { + return *m.CostInLocalCurrency + } + return 0 +} + +func (m *CGCStorePurchaseInit_LineItem) GetPurchaseType() uint32 { + if m != nil && m.PurchaseType != nil { + return *m.PurchaseType + } + return 0 +} + +func (m *CGCStorePurchaseInit_LineItem) GetSourceReferenceId() uint64 { + if m != nil && m.SourceReferenceId != nil { + return *m.SourceReferenceId + } + return 0 +} + +type CMsgGCStorePurchaseInit struct { + Country *string `protobuf:"bytes,1,opt,name=country" json:"country,omitempty"` + Language *int32 `protobuf:"varint,2,opt,name=language" json:"language,omitempty"` + Currency *int32 `protobuf:"varint,3,opt,name=currency" json:"currency,omitempty"` + LineItems []*CGCStorePurchaseInit_LineItem `protobuf:"bytes,4,rep,name=line_items" json:"line_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCStorePurchaseInit) Reset() { *m = CMsgGCStorePurchaseInit{} } +func (m *CMsgGCStorePurchaseInit) String() string { return proto.CompactTextString(m) } +func (*CMsgGCStorePurchaseInit) ProtoMessage() {} +func (*CMsgGCStorePurchaseInit) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{1} } + +func (m *CMsgGCStorePurchaseInit) GetCountry() string { + if m != nil && m.Country != nil { + return *m.Country + } + return "" +} + +func (m *CMsgGCStorePurchaseInit) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return 0 +} + +func (m *CMsgGCStorePurchaseInit) GetCurrency() int32 { + if m != nil && m.Currency != nil { + return *m.Currency + } + return 0 +} + +func (m *CMsgGCStorePurchaseInit) GetLineItems() []*CGCStorePurchaseInit_LineItem { + if m != nil { + return m.LineItems + } + return nil +} + +type CMsgGCStorePurchaseInitResponse struct { + Result *int32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + TxnId *uint64 `protobuf:"varint,2,opt,name=txn_id" json:"txn_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCStorePurchaseInitResponse) Reset() { *m = CMsgGCStorePurchaseInitResponse{} } +func (m *CMsgGCStorePurchaseInitResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCStorePurchaseInitResponse) ProtoMessage() {} +func (*CMsgGCStorePurchaseInitResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{2} } + +func (m *CMsgGCStorePurchaseInitResponse) GetResult() int32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgGCStorePurchaseInitResponse) GetTxnId() uint64 { + if m != nil && m.TxnId != nil { + return *m.TxnId + } + return 0 +} + +type CMsgSystemBroadcast struct { + Message *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSystemBroadcast) Reset() { *m = CMsgSystemBroadcast{} } +func (m *CMsgSystemBroadcast) String() string { return proto.CompactTextString(m) } +func (*CMsgSystemBroadcast) ProtoMessage() {} +func (*CMsgSystemBroadcast) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{3} } + +func (m *CMsgSystemBroadcast) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +type CMsgClientPingData struct { + RelayCodes []uint32 `protobuf:"fixed32,4,rep,packed,name=relay_codes" json:"relay_codes,omitempty"` + RelayPings []uint32 `protobuf:"varint,5,rep,packed,name=relay_pings" json:"relay_pings,omitempty"` + RegionCodes []uint32 `protobuf:"varint,8,rep,packed,name=region_codes" json:"region_codes,omitempty"` + RegionPings []uint32 `protobuf:"varint,9,rep,packed,name=region_pings" json:"region_pings,omitempty"` + RegionPingFailedBitmask *uint32 `protobuf:"varint,10,opt,name=region_ping_failed_bitmask" json:"region_ping_failed_bitmask,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPingData) Reset() { *m = CMsgClientPingData{} } +func (m *CMsgClientPingData) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPingData) ProtoMessage() {} +func (*CMsgClientPingData) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{4} } + +func (m *CMsgClientPingData) GetRelayCodes() []uint32 { + if m != nil { + return m.RelayCodes + } + return nil +} + +func (m *CMsgClientPingData) GetRelayPings() []uint32 { + if m != nil { + return m.RelayPings + } + return nil +} + +func (m *CMsgClientPingData) GetRegionCodes() []uint32 { + if m != nil { + return m.RegionCodes + } + return nil +} + +func (m *CMsgClientPingData) GetRegionPings() []uint32 { + if m != nil { + return m.RegionPings + } + return nil +} + +func (m *CMsgClientPingData) GetRegionPingFailedBitmask() uint32 { + if m != nil && m.RegionPingFailedBitmask != nil { + return *m.RegionPingFailedBitmask + } + return 0 +} + +type CMsgInviteToParty struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + ClientVersion *uint32 `protobuf:"varint,2,opt,name=client_version" json:"client_version,omitempty"` + TeamId *uint32 `protobuf:"varint,3,opt,name=team_id" json:"team_id,omitempty"` + AsCoach *bool `protobuf:"varint,4,opt,name=as_coach" json:"as_coach,omitempty"` + PingData *CMsgClientPingData `protobuf:"bytes,5,opt,name=ping_data" json:"ping_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgInviteToParty) Reset() { *m = CMsgInviteToParty{} } +func (m *CMsgInviteToParty) String() string { return proto.CompactTextString(m) } +func (*CMsgInviteToParty) ProtoMessage() {} +func (*CMsgInviteToParty) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{5} } + +func (m *CMsgInviteToParty) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgInviteToParty) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgInviteToParty) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgInviteToParty) GetAsCoach() bool { + if m != nil && m.AsCoach != nil { + return *m.AsCoach + } + return false +} + +func (m *CMsgInviteToParty) GetPingData() *CMsgClientPingData { + if m != nil { + return m.PingData + } + return nil +} + +type CMsgInviteToLobby struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + ClientVersion *uint32 `protobuf:"varint,2,opt,name=client_version" json:"client_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgInviteToLobby) Reset() { *m = CMsgInviteToLobby{} } +func (m *CMsgInviteToLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgInviteToLobby) ProtoMessage() {} +func (*CMsgInviteToLobby) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{6} } + +func (m *CMsgInviteToLobby) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgInviteToLobby) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +type CMsgInvitationCreated struct { + GroupId *uint64 `protobuf:"varint,1,opt,name=group_id" json:"group_id,omitempty"` + SteamId *uint64 `protobuf:"fixed64,2,opt,name=steam_id" json:"steam_id,omitempty"` + UserOffline *bool `protobuf:"varint,3,opt,name=user_offline" json:"user_offline,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgInvitationCreated) Reset() { *m = CMsgInvitationCreated{} } +func (m *CMsgInvitationCreated) String() string { return proto.CompactTextString(m) } +func (*CMsgInvitationCreated) ProtoMessage() {} +func (*CMsgInvitationCreated) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{7} } + +func (m *CMsgInvitationCreated) GetGroupId() uint64 { + if m != nil && m.GroupId != nil { + return *m.GroupId + } + return 0 +} + +func (m *CMsgInvitationCreated) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgInvitationCreated) GetUserOffline() bool { + if m != nil && m.UserOffline != nil { + return *m.UserOffline + } + return false +} + +type CMsgPartyInviteResponse struct { + PartyId *uint64 `protobuf:"varint,1,opt,name=party_id" json:"party_id,omitempty"` + Accept *bool `protobuf:"varint,2,opt,name=accept" json:"accept,omitempty"` + ClientVersion *uint32 `protobuf:"varint,3,opt,name=client_version" json:"client_version,omitempty"` + PingData *CMsgClientPingData `protobuf:"bytes,8,opt,name=ping_data" json:"ping_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPartyInviteResponse) Reset() { *m = CMsgPartyInviteResponse{} } +func (m *CMsgPartyInviteResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgPartyInviteResponse) ProtoMessage() {} +func (*CMsgPartyInviteResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{8} } + +func (m *CMsgPartyInviteResponse) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CMsgPartyInviteResponse) GetAccept() bool { + if m != nil && m.Accept != nil { + return *m.Accept + } + return false +} + +func (m *CMsgPartyInviteResponse) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgPartyInviteResponse) GetPingData() *CMsgClientPingData { + if m != nil { + return m.PingData + } + return nil +} + +type CMsgLobbyInviteResponse struct { + LobbyId *uint64 `protobuf:"fixed64,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + Accept *bool `protobuf:"varint,2,opt,name=accept" json:"accept,omitempty"` + ClientVersion *uint32 `protobuf:"varint,3,opt,name=client_version" json:"client_version,omitempty"` + CustomGameCrc *uint64 `protobuf:"fixed64,6,opt,name=custom_game_crc" json:"custom_game_crc,omitempty"` + CustomGameTimestamp *uint32 `protobuf:"fixed32,7,opt,name=custom_game_timestamp" json:"custom_game_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLobbyInviteResponse) Reset() { *m = CMsgLobbyInviteResponse{} } +func (m *CMsgLobbyInviteResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgLobbyInviteResponse) ProtoMessage() {} +func (*CMsgLobbyInviteResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{9} } + +func (m *CMsgLobbyInviteResponse) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgLobbyInviteResponse) GetAccept() bool { + if m != nil && m.Accept != nil { + return *m.Accept + } + return false +} + +func (m *CMsgLobbyInviteResponse) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgLobbyInviteResponse) GetCustomGameCrc() uint64 { + if m != nil && m.CustomGameCrc != nil { + return *m.CustomGameCrc + } + return 0 +} + +func (m *CMsgLobbyInviteResponse) GetCustomGameTimestamp() uint32 { + if m != nil && m.CustomGameTimestamp != nil { + return *m.CustomGameTimestamp + } + return 0 +} + +type CMsgKickFromParty struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgKickFromParty) Reset() { *m = CMsgKickFromParty{} } +func (m *CMsgKickFromParty) String() string { return proto.CompactTextString(m) } +func (*CMsgKickFromParty) ProtoMessage() {} +func (*CMsgKickFromParty) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{10} } + +func (m *CMsgKickFromParty) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CMsgLeaveParty struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLeaveParty) Reset() { *m = CMsgLeaveParty{} } +func (m *CMsgLeaveParty) String() string { return proto.CompactTextString(m) } +func (*CMsgLeaveParty) ProtoMessage() {} +func (*CMsgLeaveParty) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{11} } + +type CMsgCustomGameInstallStatus struct { + Status *ECustomGameInstallStatus `protobuf:"varint,1,opt,name=status,enum=ECustomGameInstallStatus,def=0" json:"status,omitempty"` + Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"` + LatestTimestampFromSteam *uint32 `protobuf:"fixed32,3,opt,name=latest_timestamp_from_steam" json:"latest_timestamp_from_steam,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCustomGameInstallStatus) Reset() { *m = CMsgCustomGameInstallStatus{} } +func (m *CMsgCustomGameInstallStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgCustomGameInstallStatus) ProtoMessage() {} +func (*CMsgCustomGameInstallStatus) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{12} } + +const Default_CMsgCustomGameInstallStatus_Status ECustomGameInstallStatus = ECustomGameInstallStatus_k_ECustomGameInstallStatus_Unknown + +func (m *CMsgCustomGameInstallStatus) GetStatus() ECustomGameInstallStatus { + if m != nil && m.Status != nil { + return *m.Status + } + return Default_CMsgCustomGameInstallStatus_Status +} + +func (m *CMsgCustomGameInstallStatus) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgCustomGameInstallStatus) GetLatestTimestampFromSteam() uint32 { + if m != nil && m.LatestTimestampFromSteam != nil { + return *m.LatestTimestampFromSteam + } + return 0 +} + +type CMsgServerAvailable struct { + CustomGameInstallStatus *CMsgCustomGameInstallStatus `protobuf:"bytes,1,opt,name=custom_game_install_status" json:"custom_game_install_status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgServerAvailable) Reset() { *m = CMsgServerAvailable{} } +func (m *CMsgServerAvailable) String() string { return proto.CompactTextString(m) } +func (*CMsgServerAvailable) ProtoMessage() {} +func (*CMsgServerAvailable) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{13} } + +func (m *CMsgServerAvailable) GetCustomGameInstallStatus() *CMsgCustomGameInstallStatus { + if m != nil { + return m.CustomGameInstallStatus + } + return nil +} + +type CMsgLANServerAvailable struct { + LobbyId *uint64 `protobuf:"fixed64,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLANServerAvailable) Reset() { *m = CMsgLANServerAvailable{} } +func (m *CMsgLANServerAvailable) String() string { return proto.CompactTextString(m) } +func (*CMsgLANServerAvailable) ProtoMessage() {} +func (*CMsgLANServerAvailable) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{14} } + +func (m *CMsgLANServerAvailable) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +type CSOEconGameAccountClient struct { + AdditionalBackpackSlots *uint32 `protobuf:"varint,1,opt,name=additional_backpack_slots,def=0" json:"additional_backpack_slots,omitempty"` + TrialAccount *bool `protobuf:"varint,2,opt,name=trial_account,def=0" json:"trial_account,omitempty"` + EligibleForOnlinePlay *bool `protobuf:"varint,3,opt,name=eligible_for_online_play,def=1" json:"eligible_for_online_play,omitempty"` + NeedToChooseMostHelpfulFriend *bool `protobuf:"varint,4,opt,name=need_to_choose_most_helpful_friend" json:"need_to_choose_most_helpful_friend,omitempty"` + InCoachesList *bool `protobuf:"varint,5,opt,name=in_coaches_list" json:"in_coaches_list,omitempty"` + TradeBanExpiration *uint32 `protobuf:"fixed32,6,opt,name=trade_ban_expiration" json:"trade_ban_expiration,omitempty"` + DuelBanExpiration *uint32 `protobuf:"fixed32,7,opt,name=duel_ban_expiration" json:"duel_ban_expiration,omitempty"` + PreviewItemDef *uint32 `protobuf:"varint,8,opt,name=preview_item_def,def=0" json:"preview_item_def,omitempty"` + MadeFirstPurchase *bool `protobuf:"varint,9,opt,name=made_first_purchase,def=0" json:"made_first_purchase,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconGameAccountClient) Reset() { *m = CSOEconGameAccountClient{} } +func (m *CSOEconGameAccountClient) String() string { return proto.CompactTextString(m) } +func (*CSOEconGameAccountClient) ProtoMessage() {} +func (*CSOEconGameAccountClient) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{15} } + +const Default_CSOEconGameAccountClient_AdditionalBackpackSlots uint32 = 0 +const Default_CSOEconGameAccountClient_TrialAccount bool = false +const Default_CSOEconGameAccountClient_EligibleForOnlinePlay bool = true +const Default_CSOEconGameAccountClient_PreviewItemDef uint32 = 0 +const Default_CSOEconGameAccountClient_MadeFirstPurchase bool = false + +func (m *CSOEconGameAccountClient) GetAdditionalBackpackSlots() uint32 { + if m != nil && m.AdditionalBackpackSlots != nil { + return *m.AdditionalBackpackSlots + } + return Default_CSOEconGameAccountClient_AdditionalBackpackSlots +} + +func (m *CSOEconGameAccountClient) GetTrialAccount() bool { + if m != nil && m.TrialAccount != nil { + return *m.TrialAccount + } + return Default_CSOEconGameAccountClient_TrialAccount +} + +func (m *CSOEconGameAccountClient) GetEligibleForOnlinePlay() bool { + if m != nil && m.EligibleForOnlinePlay != nil { + return *m.EligibleForOnlinePlay + } + return Default_CSOEconGameAccountClient_EligibleForOnlinePlay +} + +func (m *CSOEconGameAccountClient) GetNeedToChooseMostHelpfulFriend() bool { + if m != nil && m.NeedToChooseMostHelpfulFriend != nil { + return *m.NeedToChooseMostHelpfulFriend + } + return false +} + +func (m *CSOEconGameAccountClient) GetInCoachesList() bool { + if m != nil && m.InCoachesList != nil { + return *m.InCoachesList + } + return false +} + +func (m *CSOEconGameAccountClient) GetTradeBanExpiration() uint32 { + if m != nil && m.TradeBanExpiration != nil { + return *m.TradeBanExpiration + } + return 0 +} + +func (m *CSOEconGameAccountClient) GetDuelBanExpiration() uint32 { + if m != nil && m.DuelBanExpiration != nil { + return *m.DuelBanExpiration + } + return 0 +} + +func (m *CSOEconGameAccountClient) GetPreviewItemDef() uint32 { + if m != nil && m.PreviewItemDef != nil { + return *m.PreviewItemDef + } + return Default_CSOEconGameAccountClient_PreviewItemDef +} + +func (m *CSOEconGameAccountClient) GetMadeFirstPurchase() bool { + if m != nil && m.MadeFirstPurchase != nil { + return *m.MadeFirstPurchase + } + return Default_CSOEconGameAccountClient_MadeFirstPurchase +} + +type CSOItemCriteriaCondition struct { + Op *int32 `protobuf:"varint,1,opt,name=op" json:"op,omitempty"` + Field *string `protobuf:"bytes,2,opt,name=field" json:"field,omitempty"` + Required *bool `protobuf:"varint,3,opt,name=required" json:"required,omitempty"` + FloatValue *float32 `protobuf:"fixed32,4,opt,name=float_value" json:"float_value,omitempty"` + StringValue *string `protobuf:"bytes,5,opt,name=string_value" json:"string_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOItemCriteriaCondition) Reset() { *m = CSOItemCriteriaCondition{} } +func (m *CSOItemCriteriaCondition) String() string { return proto.CompactTextString(m) } +func (*CSOItemCriteriaCondition) ProtoMessage() {} +func (*CSOItemCriteriaCondition) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{16} } + +func (m *CSOItemCriteriaCondition) GetOp() int32 { + if m != nil && m.Op != nil { + return *m.Op + } + return 0 +} + +func (m *CSOItemCriteriaCondition) GetField() string { + if m != nil && m.Field != nil { + return *m.Field + } + return "" +} + +func (m *CSOItemCriteriaCondition) GetRequired() bool { + if m != nil && m.Required != nil { + return *m.Required + } + return false +} + +func (m *CSOItemCriteriaCondition) GetFloatValue() float32 { + if m != nil && m.FloatValue != nil { + return *m.FloatValue + } + return 0 +} + +func (m *CSOItemCriteriaCondition) GetStringValue() string { + if m != nil && m.StringValue != nil { + return *m.StringValue + } + return "" +} + +type CSOItemCriteria struct { + ItemLevel *uint32 `protobuf:"varint,1,opt,name=item_level" json:"item_level,omitempty"` + ItemQuality *int32 `protobuf:"varint,2,opt,name=item_quality" json:"item_quality,omitempty"` + ItemLevelSet *bool `protobuf:"varint,3,opt,name=item_level_set" json:"item_level_set,omitempty"` + ItemQualitySet *bool `protobuf:"varint,4,opt,name=item_quality_set" json:"item_quality_set,omitempty"` + InitialInventory *uint32 `protobuf:"varint,5,opt,name=initial_inventory" json:"initial_inventory,omitempty"` + InitialQuantity *uint32 `protobuf:"varint,6,opt,name=initial_quantity" json:"initial_quantity,omitempty"` + IgnoreEnabledFlag *bool `protobuf:"varint,8,opt,name=ignore_enabled_flag" json:"ignore_enabled_flag,omitempty"` + Conditions []*CSOItemCriteriaCondition `protobuf:"bytes,9,rep,name=conditions" json:"conditions,omitempty"` + RecentOnly *bool `protobuf:"varint,10,opt,name=recent_only" json:"recent_only,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOItemCriteria) Reset() { *m = CSOItemCriteria{} } +func (m *CSOItemCriteria) String() string { return proto.CompactTextString(m) } +func (*CSOItemCriteria) ProtoMessage() {} +func (*CSOItemCriteria) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{17} } + +func (m *CSOItemCriteria) GetItemLevel() uint32 { + if m != nil && m.ItemLevel != nil { + return *m.ItemLevel + } + return 0 +} + +func (m *CSOItemCriteria) GetItemQuality() int32 { + if m != nil && m.ItemQuality != nil { + return *m.ItemQuality + } + return 0 +} + +func (m *CSOItemCriteria) GetItemLevelSet() bool { + if m != nil && m.ItemLevelSet != nil { + return *m.ItemLevelSet + } + return false +} + +func (m *CSOItemCriteria) GetItemQualitySet() bool { + if m != nil && m.ItemQualitySet != nil { + return *m.ItemQualitySet + } + return false +} + +func (m *CSOItemCriteria) GetInitialInventory() uint32 { + if m != nil && m.InitialInventory != nil { + return *m.InitialInventory + } + return 0 +} + +func (m *CSOItemCriteria) GetInitialQuantity() uint32 { + if m != nil && m.InitialQuantity != nil { + return *m.InitialQuantity + } + return 0 +} + +func (m *CSOItemCriteria) GetIgnoreEnabledFlag() bool { + if m != nil && m.IgnoreEnabledFlag != nil { + return *m.IgnoreEnabledFlag + } + return false +} + +func (m *CSOItemCriteria) GetConditions() []*CSOItemCriteriaCondition { + if m != nil { + return m.Conditions + } + return nil +} + +func (m *CSOItemCriteria) GetRecentOnly() bool { + if m != nil && m.RecentOnly != nil { + return *m.RecentOnly + } + return false +} + +type CSOItemRecipe struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + NA *string `protobuf:"bytes,3,opt,name=n_a" json:"n_a,omitempty"` + DescInputs *string `protobuf:"bytes,4,opt,name=desc_inputs" json:"desc_inputs,omitempty"` + DescOutputs *string `protobuf:"bytes,5,opt,name=desc_outputs" json:"desc_outputs,omitempty"` + DiA *string `protobuf:"bytes,6,opt,name=di_a" json:"di_a,omitempty"` + DiB *string `protobuf:"bytes,7,opt,name=di_b" json:"di_b,omitempty"` + DiC *string `protobuf:"bytes,8,opt,name=di_c" json:"di_c,omitempty"` + DoA *string `protobuf:"bytes,9,opt,name=do_a" json:"do_a,omitempty"` + DoB *string `protobuf:"bytes,10,opt,name=do_b" json:"do_b,omitempty"` + DoC *string `protobuf:"bytes,11,opt,name=do_c" json:"do_c,omitempty"` + RequiresAllSameClass *bool `protobuf:"varint,12,opt,name=requires_all_same_class" json:"requires_all_same_class,omitempty"` + RequiresAllSameSlot *bool `protobuf:"varint,13,opt,name=requires_all_same_slot" json:"requires_all_same_slot,omitempty"` + ClassUsageForOutput *int32 `protobuf:"varint,14,opt,name=class_usage_for_output" json:"class_usage_for_output,omitempty"` + SlotUsageForOutput *int32 `protobuf:"varint,15,opt,name=slot_usage_for_output" json:"slot_usage_for_output,omitempty"` + SetForOutput *int32 `protobuf:"varint,16,opt,name=set_for_output" json:"set_for_output,omitempty"` + InputItemsCriteria []*CSOItemCriteria `protobuf:"bytes,20,rep,name=input_items_criteria" json:"input_items_criteria,omitempty"` + OutputItemsCriteria []*CSOItemCriteria `protobuf:"bytes,21,rep,name=output_items_criteria" json:"output_items_criteria,omitempty"` + InputItemDupeCounts []uint32 `protobuf:"varint,22,rep,name=input_item_dupe_counts" json:"input_item_dupe_counts,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOItemRecipe) Reset() { *m = CSOItemRecipe{} } +func (m *CSOItemRecipe) String() string { return proto.CompactTextString(m) } +func (*CSOItemRecipe) ProtoMessage() {} +func (*CSOItemRecipe) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{18} } + +func (m *CSOItemRecipe) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CSOItemRecipe) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CSOItemRecipe) GetNA() string { + if m != nil && m.NA != nil { + return *m.NA + } + return "" +} + +func (m *CSOItemRecipe) GetDescInputs() string { + if m != nil && m.DescInputs != nil { + return *m.DescInputs + } + return "" +} + +func (m *CSOItemRecipe) GetDescOutputs() string { + if m != nil && m.DescOutputs != nil { + return *m.DescOutputs + } + return "" +} + +func (m *CSOItemRecipe) GetDiA() string { + if m != nil && m.DiA != nil { + return *m.DiA + } + return "" +} + +func (m *CSOItemRecipe) GetDiB() string { + if m != nil && m.DiB != nil { + return *m.DiB + } + return "" +} + +func (m *CSOItemRecipe) GetDiC() string { + if m != nil && m.DiC != nil { + return *m.DiC + } + return "" +} + +func (m *CSOItemRecipe) GetDoA() string { + if m != nil && m.DoA != nil { + return *m.DoA + } + return "" +} + +func (m *CSOItemRecipe) GetDoB() string { + if m != nil && m.DoB != nil { + return *m.DoB + } + return "" +} + +func (m *CSOItemRecipe) GetDoC() string { + if m != nil && m.DoC != nil { + return *m.DoC + } + return "" +} + +func (m *CSOItemRecipe) GetRequiresAllSameClass() bool { + if m != nil && m.RequiresAllSameClass != nil { + return *m.RequiresAllSameClass + } + return false +} + +func (m *CSOItemRecipe) GetRequiresAllSameSlot() bool { + if m != nil && m.RequiresAllSameSlot != nil { + return *m.RequiresAllSameSlot + } + return false +} + +func (m *CSOItemRecipe) GetClassUsageForOutput() int32 { + if m != nil && m.ClassUsageForOutput != nil { + return *m.ClassUsageForOutput + } + return 0 +} + +func (m *CSOItemRecipe) GetSlotUsageForOutput() int32 { + if m != nil && m.SlotUsageForOutput != nil { + return *m.SlotUsageForOutput + } + return 0 +} + +func (m *CSOItemRecipe) GetSetForOutput() int32 { + if m != nil && m.SetForOutput != nil { + return *m.SetForOutput + } + return 0 +} + +func (m *CSOItemRecipe) GetInputItemsCriteria() []*CSOItemCriteria { + if m != nil { + return m.InputItemsCriteria + } + return nil +} + +func (m *CSOItemRecipe) GetOutputItemsCriteria() []*CSOItemCriteria { + if m != nil { + return m.OutputItemsCriteria + } + return nil +} + +func (m *CSOItemRecipe) GetInputItemDupeCounts() []uint32 { + if m != nil { + return m.InputItemDupeCounts + } + return nil +} + +type CMsgApplyStrangePart struct { + StrangePartItemId *uint64 `protobuf:"varint,1,opt,name=strange_part_item_id" json:"strange_part_item_id,omitempty"` + ItemItemId *uint64 `protobuf:"varint,2,opt,name=item_item_id" json:"item_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgApplyStrangePart) Reset() { *m = CMsgApplyStrangePart{} } +func (m *CMsgApplyStrangePart) String() string { return proto.CompactTextString(m) } +func (*CMsgApplyStrangePart) ProtoMessage() {} +func (*CMsgApplyStrangePart) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{19} } + +func (m *CMsgApplyStrangePart) GetStrangePartItemId() uint64 { + if m != nil && m.StrangePartItemId != nil { + return *m.StrangePartItemId + } + return 0 +} + +func (m *CMsgApplyStrangePart) GetItemItemId() uint64 { + if m != nil && m.ItemItemId != nil { + return *m.ItemItemId + } + return 0 +} + +type CMsgApplyPennantUpgrade struct { + UpgradeItemId *uint64 `protobuf:"varint,1,opt,name=upgrade_item_id" json:"upgrade_item_id,omitempty"` + PennantItemId *uint64 `protobuf:"varint,2,opt,name=pennant_item_id" json:"pennant_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgApplyPennantUpgrade) Reset() { *m = CMsgApplyPennantUpgrade{} } +func (m *CMsgApplyPennantUpgrade) String() string { return proto.CompactTextString(m) } +func (*CMsgApplyPennantUpgrade) ProtoMessage() {} +func (*CMsgApplyPennantUpgrade) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{20} } + +func (m *CMsgApplyPennantUpgrade) GetUpgradeItemId() uint64 { + if m != nil && m.UpgradeItemId != nil { + return *m.UpgradeItemId + } + return 0 +} + +func (m *CMsgApplyPennantUpgrade) GetPennantItemId() uint64 { + if m != nil && m.PennantItemId != nil { + return *m.PennantItemId + } + return 0 +} + +type CMsgApplyEggEssence struct { + EssenceItemId *uint64 `protobuf:"varint,1,opt,name=essence_item_id" json:"essence_item_id,omitempty"` + EggItemId *uint64 `protobuf:"varint,2,opt,name=egg_item_id" json:"egg_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgApplyEggEssence) Reset() { *m = CMsgApplyEggEssence{} } +func (m *CMsgApplyEggEssence) String() string { return proto.CompactTextString(m) } +func (*CMsgApplyEggEssence) ProtoMessage() {} +func (*CMsgApplyEggEssence) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{21} } + +func (m *CMsgApplyEggEssence) GetEssenceItemId() uint64 { + if m != nil && m.EssenceItemId != nil { + return *m.EssenceItemId + } + return 0 +} + +func (m *CMsgApplyEggEssence) GetEggItemId() uint64 { + if m != nil && m.EggItemId != nil { + return *m.EggItemId + } + return 0 +} + +type CSOEconItemAttribute struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + Value *uint32 `protobuf:"varint,2,opt,name=value" json:"value,omitempty"` + ValueBytes []byte `protobuf:"bytes,3,opt,name=value_bytes" json:"value_bytes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItemAttribute) Reset() { *m = CSOEconItemAttribute{} } +func (m *CSOEconItemAttribute) String() string { return proto.CompactTextString(m) } +func (*CSOEconItemAttribute) ProtoMessage() {} +func (*CSOEconItemAttribute) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{22} } + +func (m *CSOEconItemAttribute) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CSOEconItemAttribute) GetValue() uint32 { + if m != nil && m.Value != nil { + return *m.Value + } + return 0 +} + +func (m *CSOEconItemAttribute) GetValueBytes() []byte { + if m != nil { + return m.ValueBytes + } + return nil +} + +type CSOEconItemEquipped struct { + NewClass *uint32 `protobuf:"varint,1,opt,name=new_class" json:"new_class,omitempty"` + NewSlot *uint32 `protobuf:"varint,2,opt,name=new_slot" json:"new_slot,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItemEquipped) Reset() { *m = CSOEconItemEquipped{} } +func (m *CSOEconItemEquipped) String() string { return proto.CompactTextString(m) } +func (*CSOEconItemEquipped) ProtoMessage() {} +func (*CSOEconItemEquipped) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{23} } + +func (m *CSOEconItemEquipped) GetNewClass() uint32 { + if m != nil && m.NewClass != nil { + return *m.NewClass + } + return 0 +} + +func (m *CSOEconItemEquipped) GetNewSlot() uint32 { + if m != nil && m.NewSlot != nil { + return *m.NewSlot + } + return 0 +} + +type CSOEconItem struct { + Id *uint64 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"` + AccountId *uint32 `protobuf:"varint,2,opt,name=account_id" json:"account_id,omitempty"` + Inventory *uint32 `protobuf:"varint,3,opt,name=inventory" json:"inventory,omitempty"` + DefIndex *uint32 `protobuf:"varint,4,opt,name=def_index" json:"def_index,omitempty"` + Quantity *uint32 `protobuf:"varint,5,opt,name=quantity,def=1" json:"quantity,omitempty"` + Level *uint32 `protobuf:"varint,6,opt,name=level,def=1" json:"level,omitempty"` + Quality *uint32 `protobuf:"varint,7,opt,name=quality,def=4" json:"quality,omitempty"` + Flags *uint32 `protobuf:"varint,8,opt,name=flags,def=0" json:"flags,omitempty"` + Origin *uint32 `protobuf:"varint,9,opt,name=origin,def=0" json:"origin,omitempty"` + Attribute []*CSOEconItemAttribute `protobuf:"bytes,12,rep,name=attribute" json:"attribute,omitempty"` + InteriorItem *CSOEconItem `protobuf:"bytes,13,opt,name=interior_item" json:"interior_item,omitempty"` + InUse *bool `protobuf:"varint,14,opt,name=in_use,def=0" json:"in_use,omitempty"` + Style *uint32 `protobuf:"varint,15,opt,name=style,def=0" json:"style,omitempty"` + OriginalId *uint64 `protobuf:"varint,16,opt,name=original_id,def=0" json:"original_id,omitempty"` + EquippedState []*CSOEconItemEquipped `protobuf:"bytes,18,rep,name=equipped_state" json:"equipped_state,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItem) Reset() { *m = CSOEconItem{} } +func (m *CSOEconItem) String() string { return proto.CompactTextString(m) } +func (*CSOEconItem) ProtoMessage() {} +func (*CSOEconItem) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{24} } + +const Default_CSOEconItem_Quantity uint32 = 1 +const Default_CSOEconItem_Level uint32 = 1 +const Default_CSOEconItem_Quality uint32 = 4 +const Default_CSOEconItem_Flags uint32 = 0 +const Default_CSOEconItem_Origin uint32 = 0 +const Default_CSOEconItem_InUse bool = false +const Default_CSOEconItem_Style uint32 = 0 +const Default_CSOEconItem_OriginalId uint64 = 0 + +func (m *CSOEconItem) GetId() uint64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CSOEconItem) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSOEconItem) GetInventory() uint32 { + if m != nil && m.Inventory != nil { + return *m.Inventory + } + return 0 +} + +func (m *CSOEconItem) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CSOEconItem) GetQuantity() uint32 { + if m != nil && m.Quantity != nil { + return *m.Quantity + } + return Default_CSOEconItem_Quantity +} + +func (m *CSOEconItem) GetLevel() uint32 { + if m != nil && m.Level != nil { + return *m.Level + } + return Default_CSOEconItem_Level +} + +func (m *CSOEconItem) GetQuality() uint32 { + if m != nil && m.Quality != nil { + return *m.Quality + } + return Default_CSOEconItem_Quality +} + +func (m *CSOEconItem) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return Default_CSOEconItem_Flags +} + +func (m *CSOEconItem) GetOrigin() uint32 { + if m != nil && m.Origin != nil { + return *m.Origin + } + return Default_CSOEconItem_Origin +} + +func (m *CSOEconItem) GetAttribute() []*CSOEconItemAttribute { + if m != nil { + return m.Attribute + } + return nil +} + +func (m *CSOEconItem) GetInteriorItem() *CSOEconItem { + if m != nil { + return m.InteriorItem + } + return nil +} + +func (m *CSOEconItem) GetInUse() bool { + if m != nil && m.InUse != nil { + return *m.InUse + } + return Default_CSOEconItem_InUse +} + +func (m *CSOEconItem) GetStyle() uint32 { + if m != nil && m.Style != nil { + return *m.Style + } + return Default_CSOEconItem_Style +} + +func (m *CSOEconItem) GetOriginalId() uint64 { + if m != nil && m.OriginalId != nil { + return *m.OriginalId + } + return Default_CSOEconItem_OriginalId +} + +func (m *CSOEconItem) GetEquippedState() []*CSOEconItemEquipped { + if m != nil { + return m.EquippedState + } + return nil +} + +type CMsgSortItems struct { + SortType *uint32 `protobuf:"varint,1,opt,name=sort_type" json:"sort_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSortItems) Reset() { *m = CMsgSortItems{} } +func (m *CMsgSortItems) String() string { return proto.CompactTextString(m) } +func (*CMsgSortItems) ProtoMessage() {} +func (*CMsgSortItems) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{25} } + +func (m *CMsgSortItems) GetSortType() uint32 { + if m != nil && m.SortType != nil { + return *m.SortType + } + return 0 +} + +type CSOEconClaimCode struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + CodeType *uint32 `protobuf:"varint,2,opt,name=code_type" json:"code_type,omitempty"` + TimeAcquired *uint32 `protobuf:"varint,3,opt,name=time_acquired" json:"time_acquired,omitempty"` + Code *string `protobuf:"bytes,4,opt,name=code" json:"code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconClaimCode) Reset() { *m = CSOEconClaimCode{} } +func (m *CSOEconClaimCode) String() string { return proto.CompactTextString(m) } +func (*CSOEconClaimCode) ProtoMessage() {} +func (*CSOEconClaimCode) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{26} } + +func (m *CSOEconClaimCode) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSOEconClaimCode) GetCodeType() uint32 { + if m != nil && m.CodeType != nil { + return *m.CodeType + } + return 0 +} + +func (m *CSOEconClaimCode) GetTimeAcquired() uint32 { + if m != nil && m.TimeAcquired != nil { + return *m.TimeAcquired + } + return 0 +} + +func (m *CSOEconClaimCode) GetCode() string { + if m != nil && m.Code != nil { + return *m.Code + } + return "" +} + +type CMsgStoreGetUserData struct { + PriceSheetVersion *uint32 `protobuf:"fixed32,1,opt,name=price_sheet_version" json:"price_sheet_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgStoreGetUserData) Reset() { *m = CMsgStoreGetUserData{} } +func (m *CMsgStoreGetUserData) String() string { return proto.CompactTextString(m) } +func (*CMsgStoreGetUserData) ProtoMessage() {} +func (*CMsgStoreGetUserData) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{27} } + +func (m *CMsgStoreGetUserData) GetPriceSheetVersion() uint32 { + if m != nil && m.PriceSheetVersion != nil { + return *m.PriceSheetVersion + } + return 0 +} + +type CMsgStoreGetUserDataResponse struct { + Result *int32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + Currency *int32 `protobuf:"varint,2,opt,name=currency" json:"currency,omitempty"` + Country *string `protobuf:"bytes,3,opt,name=country" json:"country,omitempty"` + PriceSheetVersion *uint32 `protobuf:"fixed32,4,opt,name=price_sheet_version" json:"price_sheet_version,omitempty"` + ExperimentData *uint64 `protobuf:"varint,5,opt,name=experiment_data,def=0" json:"experiment_data,omitempty"` + FeaturedItemIdx *int32 `protobuf:"varint,6,opt,name=featured_item_idx" json:"featured_item_idx,omitempty"` + ShowHatDescriptions *bool `protobuf:"varint,7,opt,name=show_hat_descriptions,def=1" json:"show_hat_descriptions,omitempty"` + PriceSheet []byte `protobuf:"bytes,8,opt,name=price_sheet" json:"price_sheet,omitempty"` + DefaultItemSort *int32 `protobuf:"varint,9,opt,name=default_item_sort,def=0" json:"default_item_sort,omitempty"` + PopularItems []uint32 `protobuf:"varint,10,rep,name=popular_items" json:"popular_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgStoreGetUserDataResponse) Reset() { *m = CMsgStoreGetUserDataResponse{} } +func (m *CMsgStoreGetUserDataResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgStoreGetUserDataResponse) ProtoMessage() {} +func (*CMsgStoreGetUserDataResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{28} } + +const Default_CMsgStoreGetUserDataResponse_ExperimentData uint64 = 0 +const Default_CMsgStoreGetUserDataResponse_ShowHatDescriptions bool = true +const Default_CMsgStoreGetUserDataResponse_DefaultItemSort int32 = 0 + +func (m *CMsgStoreGetUserDataResponse) GetResult() int32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgStoreGetUserDataResponse) GetCurrency() int32 { + if m != nil && m.Currency != nil { + return *m.Currency + } + return 0 +} + +func (m *CMsgStoreGetUserDataResponse) GetCountry() string { + if m != nil && m.Country != nil { + return *m.Country + } + return "" +} + +func (m *CMsgStoreGetUserDataResponse) GetPriceSheetVersion() uint32 { + if m != nil && m.PriceSheetVersion != nil { + return *m.PriceSheetVersion + } + return 0 +} + +func (m *CMsgStoreGetUserDataResponse) GetExperimentData() uint64 { + if m != nil && m.ExperimentData != nil { + return *m.ExperimentData + } + return Default_CMsgStoreGetUserDataResponse_ExperimentData +} + +func (m *CMsgStoreGetUserDataResponse) GetFeaturedItemIdx() int32 { + if m != nil && m.FeaturedItemIdx != nil { + return *m.FeaturedItemIdx + } + return 0 +} + +func (m *CMsgStoreGetUserDataResponse) GetShowHatDescriptions() bool { + if m != nil && m.ShowHatDescriptions != nil { + return *m.ShowHatDescriptions + } + return Default_CMsgStoreGetUserDataResponse_ShowHatDescriptions +} + +func (m *CMsgStoreGetUserDataResponse) GetPriceSheet() []byte { + if m != nil { + return m.PriceSheet + } + return nil +} + +func (m *CMsgStoreGetUserDataResponse) GetDefaultItemSort() int32 { + if m != nil && m.DefaultItemSort != nil { + return *m.DefaultItemSort + } + return Default_CMsgStoreGetUserDataResponse_DefaultItemSort +} + +func (m *CMsgStoreGetUserDataResponse) GetPopularItems() []uint32 { + if m != nil { + return m.PopularItems + } + return nil +} + +type CMsgUpdateItemSchema struct { + ItemsGame []byte `protobuf:"bytes,1,opt,name=items_game" json:"items_game,omitempty"` + ItemSchemaVersion *uint32 `protobuf:"fixed32,2,opt,name=item_schema_version" json:"item_schema_version,omitempty"` + ItemsGameUrl *string `protobuf:"bytes,3,opt,name=items_game_url" json:"items_game_url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgUpdateItemSchema) Reset() { *m = CMsgUpdateItemSchema{} } +func (m *CMsgUpdateItemSchema) String() string { return proto.CompactTextString(m) } +func (*CMsgUpdateItemSchema) ProtoMessage() {} +func (*CMsgUpdateItemSchema) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{29} } + +func (m *CMsgUpdateItemSchema) GetItemsGame() []byte { + if m != nil { + return m.ItemsGame + } + return nil +} + +func (m *CMsgUpdateItemSchema) GetItemSchemaVersion() uint32 { + if m != nil && m.ItemSchemaVersion != nil { + return *m.ItemSchemaVersion + } + return 0 +} + +func (m *CMsgUpdateItemSchema) GetItemsGameUrl() string { + if m != nil && m.ItemsGameUrl != nil { + return *m.ItemsGameUrl + } + return "" +} + +type CMsgGCError struct { + ErrorText *string `protobuf:"bytes,1,opt,name=error_text" json:"error_text,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCError) Reset() { *m = CMsgGCError{} } +func (m *CMsgGCError) String() string { return proto.CompactTextString(m) } +func (*CMsgGCError) ProtoMessage() {} +func (*CMsgGCError) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{30} } + +func (m *CMsgGCError) GetErrorText() string { + if m != nil && m.ErrorText != nil { + return *m.ErrorText + } + return "" +} + +type CMsgRequestInventoryRefresh struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestInventoryRefresh) Reset() { *m = CMsgRequestInventoryRefresh{} } +func (m *CMsgRequestInventoryRefresh) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestInventoryRefresh) ProtoMessage() {} +func (*CMsgRequestInventoryRefresh) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{31} } + +type CMsgConVarValue struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgConVarValue) Reset() { *m = CMsgConVarValue{} } +func (m *CMsgConVarValue) String() string { return proto.CompactTextString(m) } +func (*CMsgConVarValue) ProtoMessage() {} +func (*CMsgConVarValue) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{32} } + +func (m *CMsgConVarValue) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgConVarValue) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CMsgReplicateConVars struct { + Convars []*CMsgConVarValue `protobuf:"bytes,1,rep,name=convars" json:"convars,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgReplicateConVars) Reset() { *m = CMsgReplicateConVars{} } +func (m *CMsgReplicateConVars) String() string { return proto.CompactTextString(m) } +func (*CMsgReplicateConVars) ProtoMessage() {} +func (*CMsgReplicateConVars) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{33} } + +func (m *CMsgReplicateConVars) GetConvars() []*CMsgConVarValue { + if m != nil { + return m.Convars + } + return nil +} + +type CMsgReplayUploadedToYouTube struct { + YoutubeUrl *string `protobuf:"bytes,1,opt,name=youtube_url" json:"youtube_url,omitempty"` + YoutubeAccountName *string `protobuf:"bytes,2,opt,name=youtube_account_name" json:"youtube_account_name,omitempty"` + SessionId *uint64 `protobuf:"varint,3,opt,name=session_id" json:"session_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgReplayUploadedToYouTube) Reset() { *m = CMsgReplayUploadedToYouTube{} } +func (m *CMsgReplayUploadedToYouTube) String() string { return proto.CompactTextString(m) } +func (*CMsgReplayUploadedToYouTube) ProtoMessage() {} +func (*CMsgReplayUploadedToYouTube) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{34} } + +func (m *CMsgReplayUploadedToYouTube) GetYoutubeUrl() string { + if m != nil && m.YoutubeUrl != nil { + return *m.YoutubeUrl + } + return "" +} + +func (m *CMsgReplayUploadedToYouTube) GetYoutubeAccountName() string { + if m != nil && m.YoutubeAccountName != nil { + return *m.YoutubeAccountName + } + return "" +} + +func (m *CMsgReplayUploadedToYouTube) GetSessionId() uint64 { + if m != nil && m.SessionId != nil { + return *m.SessionId + } + return 0 +} + +type CMsgConsumableExhausted struct { + ItemDefId *int32 `protobuf:"varint,1,opt,name=item_def_id" json:"item_def_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgConsumableExhausted) Reset() { *m = CMsgConsumableExhausted{} } +func (m *CMsgConsumableExhausted) String() string { return proto.CompactTextString(m) } +func (*CMsgConsumableExhausted) ProtoMessage() {} +func (*CMsgConsumableExhausted) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{35} } + +func (m *CMsgConsumableExhausted) GetItemDefId() int32 { + if m != nil && m.ItemDefId != nil { + return *m.ItemDefId + } + return 0 +} + +type CMsgItemAcknowledged struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Inventory *uint32 `protobuf:"varint,2,opt,name=inventory" json:"inventory,omitempty"` + DefIndex *uint32 `protobuf:"varint,3,opt,name=def_index" json:"def_index,omitempty"` + Quality *uint32 `protobuf:"varint,4,opt,name=quality" json:"quality,omitempty"` + Rarity *uint32 `protobuf:"varint,5,opt,name=rarity" json:"rarity,omitempty"` + Origin *uint32 `protobuf:"varint,6,opt,name=origin" json:"origin,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgItemAcknowledged) Reset() { *m = CMsgItemAcknowledged{} } +func (m *CMsgItemAcknowledged) String() string { return proto.CompactTextString(m) } +func (*CMsgItemAcknowledged) ProtoMessage() {} +func (*CMsgItemAcknowledged) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{36} } + +func (m *CMsgItemAcknowledged) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgItemAcknowledged) GetInventory() uint32 { + if m != nil && m.Inventory != nil { + return *m.Inventory + } + return 0 +} + +func (m *CMsgItemAcknowledged) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CMsgItemAcknowledged) GetQuality() uint32 { + if m != nil && m.Quality != nil { + return *m.Quality + } + return 0 +} + +func (m *CMsgItemAcknowledged) GetRarity() uint32 { + if m != nil && m.Rarity != nil { + return *m.Rarity + } + return 0 +} + +func (m *CMsgItemAcknowledged) GetOrigin() uint32 { + if m != nil && m.Origin != nil { + return *m.Origin + } + return 0 +} + +type CMsgSetPresetItemPosition struct { + ClassId *uint32 `protobuf:"varint,1,opt,name=class_id" json:"class_id,omitempty"` + PresetId *uint32 `protobuf:"varint,2,opt,name=preset_id" json:"preset_id,omitempty"` + SlotId *uint32 `protobuf:"varint,3,opt,name=slot_id" json:"slot_id,omitempty"` + ItemId *uint64 `protobuf:"varint,4,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSetPresetItemPosition) Reset() { *m = CMsgSetPresetItemPosition{} } +func (m *CMsgSetPresetItemPosition) String() string { return proto.CompactTextString(m) } +func (*CMsgSetPresetItemPosition) ProtoMessage() {} +func (*CMsgSetPresetItemPosition) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{37} } + +func (m *CMsgSetPresetItemPosition) GetClassId() uint32 { + if m != nil && m.ClassId != nil { + return *m.ClassId + } + return 0 +} + +func (m *CMsgSetPresetItemPosition) GetPresetId() uint32 { + if m != nil && m.PresetId != nil { + return *m.PresetId + } + return 0 +} + +func (m *CMsgSetPresetItemPosition) GetSlotId() uint32 { + if m != nil && m.SlotId != nil { + return *m.SlotId + } + return 0 +} + +func (m *CMsgSetPresetItemPosition) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgSetItemPositions struct { + ItemPositions []*CMsgSetItemPositions_ItemPosition `protobuf:"bytes,1,rep,name=item_positions" json:"item_positions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSetItemPositions) Reset() { *m = CMsgSetItemPositions{} } +func (m *CMsgSetItemPositions) String() string { return proto.CompactTextString(m) } +func (*CMsgSetItemPositions) ProtoMessage() {} +func (*CMsgSetItemPositions) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{38} } + +func (m *CMsgSetItemPositions) GetItemPositions() []*CMsgSetItemPositions_ItemPosition { + if m != nil { + return m.ItemPositions + } + return nil +} + +type CMsgSetItemPositions_ItemPosition struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + Position *uint32 `protobuf:"varint,2,opt,name=position" json:"position,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSetItemPositions_ItemPosition) Reset() { *m = CMsgSetItemPositions_ItemPosition{} } +func (m *CMsgSetItemPositions_ItemPosition) String() string { return proto.CompactTextString(m) } +func (*CMsgSetItemPositions_ItemPosition) ProtoMessage() {} +func (*CMsgSetItemPositions_ItemPosition) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{38, 0} +} + +func (m *CMsgSetItemPositions_ItemPosition) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgSetItemPositions_ItemPosition) GetPosition() uint32 { + if m != nil && m.Position != nil { + return *m.Position + } + return 0 +} + +type CSOEconItemPresetInstance struct { + ClassId *uint32 `protobuf:"varint,2,opt,name=class_id" json:"class_id,omitempty"` + PresetId *uint32 `protobuf:"varint,3,opt,name=preset_id" json:"preset_id,omitempty"` + SlotId *uint32 `protobuf:"varint,4,opt,name=slot_id" json:"slot_id,omitempty"` + ItemId *uint64 `protobuf:"varint,5,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItemPresetInstance) Reset() { *m = CSOEconItemPresetInstance{} } +func (m *CSOEconItemPresetInstance) String() string { return proto.CompactTextString(m) } +func (*CSOEconItemPresetInstance) ProtoMessage() {} +func (*CSOEconItemPresetInstance) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{39} } + +func (m *CSOEconItemPresetInstance) GetClassId() uint32 { + if m != nil && m.ClassId != nil { + return *m.ClassId + } + return 0 +} + +func (m *CSOEconItemPresetInstance) GetPresetId() uint32 { + if m != nil && m.PresetId != nil { + return *m.PresetId + } + return 0 +} + +func (m *CSOEconItemPresetInstance) GetSlotId() uint32 { + if m != nil && m.SlotId != nil { + return *m.SlotId + } + return 0 +} + +func (m *CSOEconItemPresetInstance) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgSelectItemPresetForClass struct { + ClassId *uint32 `protobuf:"varint,1,opt,name=class_id" json:"class_id,omitempty"` + PresetId *uint32 `protobuf:"varint,2,opt,name=preset_id" json:"preset_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSelectItemPresetForClass) Reset() { *m = CMsgSelectItemPresetForClass{} } +func (m *CMsgSelectItemPresetForClass) String() string { return proto.CompactTextString(m) } +func (*CMsgSelectItemPresetForClass) ProtoMessage() {} +func (*CMsgSelectItemPresetForClass) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{40} } + +func (m *CMsgSelectItemPresetForClass) GetClassId() uint32 { + if m != nil && m.ClassId != nil { + return *m.ClassId + } + return 0 +} + +func (m *CMsgSelectItemPresetForClass) GetPresetId() uint32 { + if m != nil && m.PresetId != nil { + return *m.PresetId + } + return 0 +} + +type CMsgSelectItemPresetForClassReply struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSelectItemPresetForClassReply) Reset() { *m = CMsgSelectItemPresetForClassReply{} } +func (m *CMsgSelectItemPresetForClassReply) String() string { return proto.CompactTextString(m) } +func (*CMsgSelectItemPresetForClassReply) ProtoMessage() {} +func (*CMsgSelectItemPresetForClassReply) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{41} +} + +func (m *CMsgSelectItemPresetForClassReply) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +type CSOSelectedItemPreset struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ClassId *uint32 `protobuf:"varint,2,opt,name=class_id" json:"class_id,omitempty"` + PresetId *uint32 `protobuf:"varint,3,opt,name=preset_id" json:"preset_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOSelectedItemPreset) Reset() { *m = CSOSelectedItemPreset{} } +func (m *CSOSelectedItemPreset) String() string { return proto.CompactTextString(m) } +func (*CSOSelectedItemPreset) ProtoMessage() {} +func (*CSOSelectedItemPreset) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{42} } + +func (m *CSOSelectedItemPreset) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSOSelectedItemPreset) GetClassId() uint32 { + if m != nil && m.ClassId != nil { + return *m.ClassId + } + return 0 +} + +func (m *CSOSelectedItemPreset) GetPresetId() uint32 { + if m != nil && m.PresetId != nil { + return *m.PresetId + } + return 0 +} + +type CMsgGCNameItemNotification struct { + PlayerSteamid *uint64 `protobuf:"fixed64,1,opt,name=player_steamid" json:"player_steamid,omitempty"` + ItemDefIndex *uint32 `protobuf:"varint,2,opt,name=item_def_index" json:"item_def_index,omitempty"` + ItemNameCustom *string `protobuf:"bytes,3,opt,name=item_name_custom" json:"item_name_custom,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCNameItemNotification) Reset() { *m = CMsgGCNameItemNotification{} } +func (m *CMsgGCNameItemNotification) String() string { return proto.CompactTextString(m) } +func (*CMsgGCNameItemNotification) ProtoMessage() {} +func (*CMsgGCNameItemNotification) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{43} } + +func (m *CMsgGCNameItemNotification) GetPlayerSteamid() uint64 { + if m != nil && m.PlayerSteamid != nil { + return *m.PlayerSteamid + } + return 0 +} + +func (m *CMsgGCNameItemNotification) GetItemDefIndex() uint32 { + if m != nil && m.ItemDefIndex != nil { + return *m.ItemDefIndex + } + return 0 +} + +func (m *CMsgGCNameItemNotification) GetItemNameCustom() string { + if m != nil && m.ItemNameCustom != nil { + return *m.ItemNameCustom + } + return "" +} + +type CMsgGCClientDisplayNotification struct { + NotificationTitleLocalizationKey *string `protobuf:"bytes,1,opt,name=notification_title_localization_key" json:"notification_title_localization_key,omitempty"` + NotificationBodyLocalizationKey *string `protobuf:"bytes,2,opt,name=notification_body_localization_key" json:"notification_body_localization_key,omitempty"` + BodySubstringKeys []string `protobuf:"bytes,3,rep,name=body_substring_keys" json:"body_substring_keys,omitempty"` + BodySubstringValues []string `protobuf:"bytes,4,rep,name=body_substring_values" json:"body_substring_values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCClientDisplayNotification) Reset() { *m = CMsgGCClientDisplayNotification{} } +func (m *CMsgGCClientDisplayNotification) String() string { return proto.CompactTextString(m) } +func (*CMsgGCClientDisplayNotification) ProtoMessage() {} +func (*CMsgGCClientDisplayNotification) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{44} +} + +func (m *CMsgGCClientDisplayNotification) GetNotificationTitleLocalizationKey() string { + if m != nil && m.NotificationTitleLocalizationKey != nil { + return *m.NotificationTitleLocalizationKey + } + return "" +} + +func (m *CMsgGCClientDisplayNotification) GetNotificationBodyLocalizationKey() string { + if m != nil && m.NotificationBodyLocalizationKey != nil { + return *m.NotificationBodyLocalizationKey + } + return "" +} + +func (m *CMsgGCClientDisplayNotification) GetBodySubstringKeys() []string { + if m != nil { + return m.BodySubstringKeys + } + return nil +} + +func (m *CMsgGCClientDisplayNotification) GetBodySubstringValues() []string { + if m != nil { + return m.BodySubstringValues + } + return nil +} + +type CMsgGCShowItemsPickedUp struct { + PlayerSteamid *uint64 `protobuf:"fixed64,1,opt,name=player_steamid" json:"player_steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCShowItemsPickedUp) Reset() { *m = CMsgGCShowItemsPickedUp{} } +func (m *CMsgGCShowItemsPickedUp) String() string { return proto.CompactTextString(m) } +func (*CMsgGCShowItemsPickedUp) ProtoMessage() {} +func (*CMsgGCShowItemsPickedUp) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{45} } + +func (m *CMsgGCShowItemsPickedUp) GetPlayerSteamid() uint64 { + if m != nil && m.PlayerSteamid != nil { + return *m.PlayerSteamid + } + return 0 +} + +type CMsgGCIncrementKillCountResponse struct { + KillerAccountId *uint32 `protobuf:"varint,1,opt,name=killer_account_id" json:"killer_account_id,omitempty"` + NumKills *uint32 `protobuf:"varint,2,opt,name=num_kills" json:"num_kills,omitempty"` + ItemDef *uint32 `protobuf:"varint,3,opt,name=item_def" json:"item_def,omitempty"` + LevelType *uint32 `protobuf:"varint,4,opt,name=level_type" json:"level_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCIncrementKillCountResponse) Reset() { *m = CMsgGCIncrementKillCountResponse{} } +func (m *CMsgGCIncrementKillCountResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCIncrementKillCountResponse) ProtoMessage() {} +func (*CMsgGCIncrementKillCountResponse) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{46} +} + +func (m *CMsgGCIncrementKillCountResponse) GetKillerAccountId() uint32 { + if m != nil && m.KillerAccountId != nil { + return *m.KillerAccountId + } + return 0 +} + +func (m *CMsgGCIncrementKillCountResponse) GetNumKills() uint32 { + if m != nil && m.NumKills != nil { + return *m.NumKills + } + return 0 +} + +func (m *CMsgGCIncrementKillCountResponse) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +func (m *CMsgGCIncrementKillCountResponse) GetLevelType() uint32 { + if m != nil && m.LevelType != nil { + return *m.LevelType + } + return 0 +} + +type CSOEconItemDropRateBonus struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ExpirationDate *uint32 `protobuf:"fixed32,2,opt,name=expiration_date" json:"expiration_date,omitempty"` + Bonus *float32 `protobuf:"fixed32,3,opt,name=bonus" json:"bonus,omitempty"` + BonusCount *uint32 `protobuf:"varint,4,opt,name=bonus_count" json:"bonus_count,omitempty"` + ItemId *uint64 `protobuf:"varint,5,opt,name=item_id" json:"item_id,omitempty"` + DefIndex *uint32 `protobuf:"varint,6,opt,name=def_index" json:"def_index,omitempty"` + SecondsLeft *uint32 `protobuf:"varint,7,opt,name=seconds_left" json:"seconds_left,omitempty"` + BoosterType *uint32 `protobuf:"varint,8,opt,name=booster_type" json:"booster_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItemDropRateBonus) Reset() { *m = CSOEconItemDropRateBonus{} } +func (m *CSOEconItemDropRateBonus) String() string { return proto.CompactTextString(m) } +func (*CSOEconItemDropRateBonus) ProtoMessage() {} +func (*CSOEconItemDropRateBonus) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{47} } + +func (m *CSOEconItemDropRateBonus) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSOEconItemDropRateBonus) GetExpirationDate() uint32 { + if m != nil && m.ExpirationDate != nil { + return *m.ExpirationDate + } + return 0 +} + +func (m *CSOEconItemDropRateBonus) GetBonus() float32 { + if m != nil && m.Bonus != nil { + return *m.Bonus + } + return 0 +} + +func (m *CSOEconItemDropRateBonus) GetBonusCount() uint32 { + if m != nil && m.BonusCount != nil { + return *m.BonusCount + } + return 0 +} + +func (m *CSOEconItemDropRateBonus) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CSOEconItemDropRateBonus) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CSOEconItemDropRateBonus) GetSecondsLeft() uint32 { + if m != nil && m.SecondsLeft != nil { + return *m.SecondsLeft + } + return 0 +} + +func (m *CSOEconItemDropRateBonus) GetBoosterType() uint32 { + if m != nil && m.BoosterType != nil { + return *m.BoosterType + } + return 0 +} + +type CSOEconItemLeagueViewPass struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + Itemindex *uint32 `protobuf:"varint,4,opt,name=itemindex" json:"itemindex,omitempty"` + GrantReason *uint32 `protobuf:"varint,5,opt,name=grant_reason" json:"grant_reason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItemLeagueViewPass) Reset() { *m = CSOEconItemLeagueViewPass{} } +func (m *CSOEconItemLeagueViewPass) String() string { return proto.CompactTextString(m) } +func (*CSOEconItemLeagueViewPass) ProtoMessage() {} +func (*CSOEconItemLeagueViewPass) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{48} } + +func (m *CSOEconItemLeagueViewPass) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSOEconItemLeagueViewPass) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CSOEconItemLeagueViewPass) GetItemindex() uint32 { + if m != nil && m.Itemindex != nil { + return *m.Itemindex + } + return 0 +} + +func (m *CSOEconItemLeagueViewPass) GetGrantReason() uint32 { + if m != nil && m.GrantReason != nil { + return *m.GrantReason + } + return 0 +} + +type CSOEconItemEventTicket struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + EventId *uint32 `protobuf:"varint,2,opt,name=event_id" json:"event_id,omitempty"` + ItemId *uint64 `protobuf:"varint,3,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItemEventTicket) Reset() { *m = CSOEconItemEventTicket{} } +func (m *CSOEconItemEventTicket) String() string { return proto.CompactTextString(m) } +func (*CSOEconItemEventTicket) ProtoMessage() {} +func (*CSOEconItemEventTicket) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{49} } + +func (m *CSOEconItemEventTicket) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSOEconItemEventTicket) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CSOEconItemEventTicket) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CSOEconItemTournamentPassport struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + ItemId *uint64 `protobuf:"varint,3,opt,name=item_id" json:"item_id,omitempty"` + OriginalPurchaserId *uint32 `protobuf:"varint,4,opt,name=original_purchaser_id" json:"original_purchaser_id,omitempty"` + PassportsBought *uint32 `protobuf:"varint,5,opt,name=passports_bought" json:"passports_bought,omitempty"` + Version *uint32 `protobuf:"varint,6,opt,name=version" json:"version,omitempty"` + DefIndex *uint32 `protobuf:"varint,7,opt,name=def_index" json:"def_index,omitempty"` + RewardFlags *uint32 `protobuf:"varint,8,opt,name=reward_flags" json:"reward_flags,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSOEconItemTournamentPassport) Reset() { *m = CSOEconItemTournamentPassport{} } +func (m *CSOEconItemTournamentPassport) String() string { return proto.CompactTextString(m) } +func (*CSOEconItemTournamentPassport) ProtoMessage() {} +func (*CSOEconItemTournamentPassport) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{50} } + +func (m *CSOEconItemTournamentPassport) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSOEconItemTournamentPassport) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CSOEconItemTournamentPassport) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CSOEconItemTournamentPassport) GetOriginalPurchaserId() uint32 { + if m != nil && m.OriginalPurchaserId != nil { + return *m.OriginalPurchaserId + } + return 0 +} + +func (m *CSOEconItemTournamentPassport) GetPassportsBought() uint32 { + if m != nil && m.PassportsBought != nil { + return *m.PassportsBought + } + return 0 +} + +func (m *CSOEconItemTournamentPassport) GetVersion() uint32 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CSOEconItemTournamentPassport) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CSOEconItemTournamentPassport) GetRewardFlags() uint32 { + if m != nil && m.RewardFlags != nil { + return *m.RewardFlags + } + return 0 +} + +type CMsgGCItemPreviewItemBoughtNotification struct { + ItemDefIndex *uint32 `protobuf:"varint,1,opt,name=item_def_index" json:"item_def_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemPreviewItemBoughtNotification) Reset() { + *m = CMsgGCItemPreviewItemBoughtNotification{} +} +func (m *CMsgGCItemPreviewItemBoughtNotification) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemPreviewItemBoughtNotification) ProtoMessage() {} +func (*CMsgGCItemPreviewItemBoughtNotification) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{51} +} + +func (m *CMsgGCItemPreviewItemBoughtNotification) GetItemDefIndex() uint32 { + if m != nil && m.ItemDefIndex != nil { + return *m.ItemDefIndex + } + return 0 +} + +type CMsgGCStorePurchaseCancel struct { + TxnId *uint64 `protobuf:"varint,1,opt,name=txn_id" json:"txn_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCStorePurchaseCancel) Reset() { *m = CMsgGCStorePurchaseCancel{} } +func (m *CMsgGCStorePurchaseCancel) String() string { return proto.CompactTextString(m) } +func (*CMsgGCStorePurchaseCancel) ProtoMessage() {} +func (*CMsgGCStorePurchaseCancel) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{52} } + +func (m *CMsgGCStorePurchaseCancel) GetTxnId() uint64 { + if m != nil && m.TxnId != nil { + return *m.TxnId + } + return 0 +} + +type CMsgGCStorePurchaseCancelResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCStorePurchaseCancelResponse) Reset() { *m = CMsgGCStorePurchaseCancelResponse{} } +func (m *CMsgGCStorePurchaseCancelResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCStorePurchaseCancelResponse) ProtoMessage() {} +func (*CMsgGCStorePurchaseCancelResponse) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{53} +} + +func (m *CMsgGCStorePurchaseCancelResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgGCStorePurchaseFinalize struct { + TxnId *uint64 `protobuf:"varint,1,opt,name=txn_id" json:"txn_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCStorePurchaseFinalize) Reset() { *m = CMsgGCStorePurchaseFinalize{} } +func (m *CMsgGCStorePurchaseFinalize) String() string { return proto.CompactTextString(m) } +func (*CMsgGCStorePurchaseFinalize) ProtoMessage() {} +func (*CMsgGCStorePurchaseFinalize) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{54} } + +func (m *CMsgGCStorePurchaseFinalize) GetTxnId() uint64 { + if m != nil && m.TxnId != nil { + return *m.TxnId + } + return 0 +} + +type CMsgGCStorePurchaseFinalizeResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + ItemIds []uint64 `protobuf:"varint,2,rep,name=item_ids" json:"item_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCStorePurchaseFinalizeResponse) Reset() { *m = CMsgGCStorePurchaseFinalizeResponse{} } +func (m *CMsgGCStorePurchaseFinalizeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCStorePurchaseFinalizeResponse) ProtoMessage() {} +func (*CMsgGCStorePurchaseFinalizeResponse) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{55} +} + +func (m *CMsgGCStorePurchaseFinalizeResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgGCStorePurchaseFinalizeResponse) GetItemIds() []uint64 { + if m != nil { + return m.ItemIds + } + return nil +} + +type CMsgGCBannedWordListRequest struct { + BanListGroupId *uint32 `protobuf:"varint,1,opt,name=ban_list_group_id" json:"ban_list_group_id,omitempty"` + WordId *uint32 `protobuf:"varint,2,opt,name=word_id" json:"word_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCBannedWordListRequest) Reset() { *m = CMsgGCBannedWordListRequest{} } +func (m *CMsgGCBannedWordListRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCBannedWordListRequest) ProtoMessage() {} +func (*CMsgGCBannedWordListRequest) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{56} } + +func (m *CMsgGCBannedWordListRequest) GetBanListGroupId() uint32 { + if m != nil && m.BanListGroupId != nil { + return *m.BanListGroupId + } + return 0 +} + +func (m *CMsgGCBannedWordListRequest) GetWordId() uint32 { + if m != nil && m.WordId != nil { + return *m.WordId + } + return 0 +} + +type CMsgGCBannedWord struct { + WordId *uint32 `protobuf:"varint,1,opt,name=word_id" json:"word_id,omitempty"` + WordType *GC_BannedWordType `protobuf:"varint,2,opt,name=word_type,enum=GC_BannedWordType,def=0" json:"word_type,omitempty"` + Word *string `protobuf:"bytes,3,opt,name=word" json:"word,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCBannedWord) Reset() { *m = CMsgGCBannedWord{} } +func (m *CMsgGCBannedWord) String() string { return proto.CompactTextString(m) } +func (*CMsgGCBannedWord) ProtoMessage() {} +func (*CMsgGCBannedWord) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{57} } + +const Default_CMsgGCBannedWord_WordType GC_BannedWordType = GC_BannedWordType_GC_BANNED_WORD_DISABLE_WORD + +func (m *CMsgGCBannedWord) GetWordId() uint32 { + if m != nil && m.WordId != nil { + return *m.WordId + } + return 0 +} + +func (m *CMsgGCBannedWord) GetWordType() GC_BannedWordType { + if m != nil && m.WordType != nil { + return *m.WordType + } + return Default_CMsgGCBannedWord_WordType +} + +func (m *CMsgGCBannedWord) GetWord() string { + if m != nil && m.Word != nil { + return *m.Word + } + return "" +} + +type CMsgGCBannedWordListResponse struct { + BanListGroupId *uint32 `protobuf:"varint,1,opt,name=ban_list_group_id" json:"ban_list_group_id,omitempty"` + WordList []*CMsgGCBannedWord `protobuf:"bytes,2,rep,name=word_list" json:"word_list,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCBannedWordListResponse) Reset() { *m = CMsgGCBannedWordListResponse{} } +func (m *CMsgGCBannedWordListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCBannedWordListResponse) ProtoMessage() {} +func (*CMsgGCBannedWordListResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{58} } + +func (m *CMsgGCBannedWordListResponse) GetBanListGroupId() uint32 { + if m != nil && m.BanListGroupId != nil { + return *m.BanListGroupId + } + return 0 +} + +func (m *CMsgGCBannedWordListResponse) GetWordList() []*CMsgGCBannedWord { + if m != nil { + return m.WordList + } + return nil +} + +type CMsgGCToGCBannedWordListBroadcast struct { + Broadcast *CMsgGCBannedWordListResponse `protobuf:"bytes,1,opt,name=broadcast" json:"broadcast,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCBannedWordListBroadcast) Reset() { *m = CMsgGCToGCBannedWordListBroadcast{} } +func (m *CMsgGCToGCBannedWordListBroadcast) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCBannedWordListBroadcast) ProtoMessage() {} +func (*CMsgGCToGCBannedWordListBroadcast) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{59} +} + +func (m *CMsgGCToGCBannedWordListBroadcast) GetBroadcast() *CMsgGCBannedWordListResponse { + if m != nil { + return m.Broadcast + } + return nil +} + +type CMsgGCToGCBannedWordListUpdated struct { + GroupId *uint32 `protobuf:"varint,1,opt,name=group_id" json:"group_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCBannedWordListUpdated) Reset() { *m = CMsgGCToGCBannedWordListUpdated{} } +func (m *CMsgGCToGCBannedWordListUpdated) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCBannedWordListUpdated) ProtoMessage() {} +func (*CMsgGCToGCBannedWordListUpdated) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{60} +} + +func (m *CMsgGCToGCBannedWordListUpdated) GetGroupId() uint32 { + if m != nil && m.GroupId != nil { + return *m.GroupId + } + return 0 +} + +type CMsgGCToGCDirtySDOCache struct { + SdoType *uint32 `protobuf:"varint,1,opt,name=sdo_type" json:"sdo_type,omitempty"` + KeyUint64 *uint64 `protobuf:"varint,2,opt,name=key_uint64" json:"key_uint64,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCDirtySDOCache) Reset() { *m = CMsgGCToGCDirtySDOCache{} } +func (m *CMsgGCToGCDirtySDOCache) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCDirtySDOCache) ProtoMessage() {} +func (*CMsgGCToGCDirtySDOCache) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{61} } + +func (m *CMsgGCToGCDirtySDOCache) GetSdoType() uint32 { + if m != nil && m.SdoType != nil { + return *m.SdoType + } + return 0 +} + +func (m *CMsgGCToGCDirtySDOCache) GetKeyUint64() uint64 { + if m != nil && m.KeyUint64 != nil { + return *m.KeyUint64 + } + return 0 +} + +type CMsgGCToGCDirtyMultipleSDOCache struct { + SdoType *uint32 `protobuf:"varint,1,opt,name=sdo_type" json:"sdo_type,omitempty"` + KeyUint64 []uint64 `protobuf:"varint,2,rep,name=key_uint64" json:"key_uint64,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCDirtyMultipleSDOCache) Reset() { *m = CMsgGCToGCDirtyMultipleSDOCache{} } +func (m *CMsgGCToGCDirtyMultipleSDOCache) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCDirtyMultipleSDOCache) ProtoMessage() {} +func (*CMsgGCToGCDirtyMultipleSDOCache) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{62} +} + +func (m *CMsgGCToGCDirtyMultipleSDOCache) GetSdoType() uint32 { + if m != nil && m.SdoType != nil { + return *m.SdoType + } + return 0 +} + +func (m *CMsgGCToGCDirtyMultipleSDOCache) GetKeyUint64() []uint64 { + if m != nil { + return m.KeyUint64 + } + return nil +} + +type CMsgGCToGCApplyLocalizationDiff struct { + Language *uint32 `protobuf:"varint,1,opt,name=language" json:"language,omitempty"` + PackedDiff *string `protobuf:"bytes,2,opt,name=packed_diff" json:"packed_diff,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCApplyLocalizationDiff) Reset() { *m = CMsgGCToGCApplyLocalizationDiff{} } +func (m *CMsgGCToGCApplyLocalizationDiff) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCApplyLocalizationDiff) ProtoMessage() {} +func (*CMsgGCToGCApplyLocalizationDiff) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{63} +} + +func (m *CMsgGCToGCApplyLocalizationDiff) GetLanguage() uint32 { + if m != nil && m.Language != nil { + return *m.Language + } + return 0 +} + +func (m *CMsgGCToGCApplyLocalizationDiff) GetPackedDiff() string { + if m != nil && m.PackedDiff != nil { + return *m.PackedDiff + } + return "" +} + +type CMsgGCToGCApplyLocalizationDiffResponse struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCApplyLocalizationDiffResponse) Reset() { + *m = CMsgGCToGCApplyLocalizationDiffResponse{} +} +func (m *CMsgGCToGCApplyLocalizationDiffResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCApplyLocalizationDiffResponse) ProtoMessage() {} +func (*CMsgGCToGCApplyLocalizationDiffResponse) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{64} +} + +func (m *CMsgGCToGCApplyLocalizationDiffResponse) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +type CMsgGCCollectItem struct { + CollectionItemId *uint64 `protobuf:"varint,1,opt,name=collection_item_id" json:"collection_item_id,omitempty"` + SubjectItemId *uint64 `protobuf:"varint,2,opt,name=subject_item_id" json:"subject_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCCollectItem) Reset() { *m = CMsgGCCollectItem{} } +func (m *CMsgGCCollectItem) String() string { return proto.CompactTextString(m) } +func (*CMsgGCCollectItem) ProtoMessage() {} +func (*CMsgGCCollectItem) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{65} } + +func (m *CMsgGCCollectItem) GetCollectionItemId() uint64 { + if m != nil && m.CollectionItemId != nil { + return *m.CollectionItemId + } + return 0 +} + +func (m *CMsgGCCollectItem) GetSubjectItemId() uint64 { + if m != nil && m.SubjectItemId != nil { + return *m.SubjectItemId + } + return 0 +} + +type CMsgSDONoMemcached struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSDONoMemcached) Reset() { *m = CMsgSDONoMemcached{} } +func (m *CMsgSDONoMemcached) String() string { return proto.CompactTextString(m) } +func (*CMsgSDONoMemcached) ProtoMessage() {} +func (*CMsgSDONoMemcached) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{66} } + +type CMsgGCToGCUpdateSQLKeyValue struct { + KeyName *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCUpdateSQLKeyValue) Reset() { *m = CMsgGCToGCUpdateSQLKeyValue{} } +func (m *CMsgGCToGCUpdateSQLKeyValue) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCUpdateSQLKeyValue) ProtoMessage() {} +func (*CMsgGCToGCUpdateSQLKeyValue) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{67} } + +func (m *CMsgGCToGCUpdateSQLKeyValue) GetKeyName() string { + if m != nil && m.KeyName != nil { + return *m.KeyName + } + return "" +} + +type CMsgGCToGCBroadcastConsoleCommand struct { + ConCommand *string `protobuf:"bytes,1,opt,name=con_command" json:"con_command,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCBroadcastConsoleCommand) Reset() { *m = CMsgGCToGCBroadcastConsoleCommand{} } +func (m *CMsgGCToGCBroadcastConsoleCommand) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCBroadcastConsoleCommand) ProtoMessage() {} +func (*CMsgGCToGCBroadcastConsoleCommand) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{68} +} + +func (m *CMsgGCToGCBroadcastConsoleCommand) GetConCommand() string { + if m != nil && m.ConCommand != nil { + return *m.ConCommand + } + return "" +} + +type CMsgGCServerVersionUpdated struct { + ServerVersion *uint32 `protobuf:"varint,1,opt,name=server_version" json:"server_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCServerVersionUpdated) Reset() { *m = CMsgGCServerVersionUpdated{} } +func (m *CMsgGCServerVersionUpdated) String() string { return proto.CompactTextString(m) } +func (*CMsgGCServerVersionUpdated) ProtoMessage() {} +func (*CMsgGCServerVersionUpdated) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{69} } + +func (m *CMsgGCServerVersionUpdated) GetServerVersion() uint32 { + if m != nil && m.ServerVersion != nil { + return *m.ServerVersion + } + return 0 +} + +type CMsgGCClientVersionUpdated struct { + ClientVersion *uint32 `protobuf:"varint,1,opt,name=client_version" json:"client_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCClientVersionUpdated) Reset() { *m = CMsgGCClientVersionUpdated{} } +func (m *CMsgGCClientVersionUpdated) String() string { return proto.CompactTextString(m) } +func (*CMsgGCClientVersionUpdated) ProtoMessage() {} +func (*CMsgGCClientVersionUpdated) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{70} } + +func (m *CMsgGCClientVersionUpdated) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +type CMsgGCToGCWebAPIAccountChanged struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCWebAPIAccountChanged) Reset() { *m = CMsgGCToGCWebAPIAccountChanged{} } +func (m *CMsgGCToGCWebAPIAccountChanged) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCWebAPIAccountChanged) ProtoMessage() {} +func (*CMsgGCToGCWebAPIAccountChanged) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{71} } + +type CMsgRecipeComponent struct { + SubjectItemId *uint64 `protobuf:"varint,1,opt,name=subject_item_id" json:"subject_item_id,omitempty"` + AttributeIndex *uint64 `protobuf:"varint,2,opt,name=attribute_index" json:"attribute_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRecipeComponent) Reset() { *m = CMsgRecipeComponent{} } +func (m *CMsgRecipeComponent) String() string { return proto.CompactTextString(m) } +func (*CMsgRecipeComponent) ProtoMessage() {} +func (*CMsgRecipeComponent) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{72} } + +func (m *CMsgRecipeComponent) GetSubjectItemId() uint64 { + if m != nil && m.SubjectItemId != nil { + return *m.SubjectItemId + } + return 0 +} + +func (m *CMsgRecipeComponent) GetAttributeIndex() uint64 { + if m != nil && m.AttributeIndex != nil { + return *m.AttributeIndex + } + return 0 +} + +type CMsgFulfillDynamicRecipeComponent struct { + ToolItemId *uint64 `protobuf:"varint,1,opt,name=tool_item_id" json:"tool_item_id,omitempty"` + ConsumptionComponents []*CMsgRecipeComponent `protobuf:"bytes,2,rep,name=consumption_components" json:"consumption_components,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFulfillDynamicRecipeComponent) Reset() { *m = CMsgFulfillDynamicRecipeComponent{} } +func (m *CMsgFulfillDynamicRecipeComponent) String() string { return proto.CompactTextString(m) } +func (*CMsgFulfillDynamicRecipeComponent) ProtoMessage() {} +func (*CMsgFulfillDynamicRecipeComponent) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{73} +} + +func (m *CMsgFulfillDynamicRecipeComponent) GetToolItemId() uint64 { + if m != nil && m.ToolItemId != nil { + return *m.ToolItemId + } + return 0 +} + +func (m *CMsgFulfillDynamicRecipeComponent) GetConsumptionComponents() []*CMsgRecipeComponent { + if m != nil { + return m.ConsumptionComponents + } + return nil +} + +type CMsgGCClientMarketDataRequest struct { + UserCurrency *uint32 `protobuf:"varint,1,opt,name=user_currency" json:"user_currency,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCClientMarketDataRequest) Reset() { *m = CMsgGCClientMarketDataRequest{} } +func (m *CMsgGCClientMarketDataRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCClientMarketDataRequest) ProtoMessage() {} +func (*CMsgGCClientMarketDataRequest) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{74} } + +func (m *CMsgGCClientMarketDataRequest) GetUserCurrency() uint32 { + if m != nil && m.UserCurrency != nil { + return *m.UserCurrency + } + return 0 +} + +type CMsgGCClientMarketDataEntry struct { + ItemDefIndex *uint32 `protobuf:"varint,1,opt,name=item_def_index" json:"item_def_index,omitempty"` + ItemQuality *uint32 `protobuf:"varint,2,opt,name=item_quality" json:"item_quality,omitempty"` + ItemSellListings *uint32 `protobuf:"varint,3,opt,name=item_sell_listings" json:"item_sell_listings,omitempty"` + PriceInLocalCurrency *uint32 `protobuf:"varint,4,opt,name=price_in_local_currency" json:"price_in_local_currency,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCClientMarketDataEntry) Reset() { *m = CMsgGCClientMarketDataEntry{} } +func (m *CMsgGCClientMarketDataEntry) String() string { return proto.CompactTextString(m) } +func (*CMsgGCClientMarketDataEntry) ProtoMessage() {} +func (*CMsgGCClientMarketDataEntry) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{75} } + +func (m *CMsgGCClientMarketDataEntry) GetItemDefIndex() uint32 { + if m != nil && m.ItemDefIndex != nil { + return *m.ItemDefIndex + } + return 0 +} + +func (m *CMsgGCClientMarketDataEntry) GetItemQuality() uint32 { + if m != nil && m.ItemQuality != nil { + return *m.ItemQuality + } + return 0 +} + +func (m *CMsgGCClientMarketDataEntry) GetItemSellListings() uint32 { + if m != nil && m.ItemSellListings != nil { + return *m.ItemSellListings + } + return 0 +} + +func (m *CMsgGCClientMarketDataEntry) GetPriceInLocalCurrency() uint32 { + if m != nil && m.PriceInLocalCurrency != nil { + return *m.PriceInLocalCurrency + } + return 0 +} + +type CMsgGCClientMarketData struct { + Entries []*CMsgGCClientMarketDataEntry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCClientMarketData) Reset() { *m = CMsgGCClientMarketData{} } +func (m *CMsgGCClientMarketData) String() string { return proto.CompactTextString(m) } +func (*CMsgGCClientMarketData) ProtoMessage() {} +func (*CMsgGCClientMarketData) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{76} } + +func (m *CMsgGCClientMarketData) GetEntries() []*CMsgGCClientMarketDataEntry { + if m != nil { + return m.Entries + } + return nil +} + +type CMsgExtractGems struct { + ToolItemId *uint64 `protobuf:"varint,1,opt,name=tool_item_id" json:"tool_item_id,omitempty"` + ItemItemId *uint64 `protobuf:"varint,2,opt,name=item_item_id" json:"item_item_id,omitempty"` + ItemSocketId *uint32 `protobuf:"varint,3,opt,name=item_socket_id,def=65535" json:"item_socket_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgExtractGems) Reset() { *m = CMsgExtractGems{} } +func (m *CMsgExtractGems) String() string { return proto.CompactTextString(m) } +func (*CMsgExtractGems) ProtoMessage() {} +func (*CMsgExtractGems) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{77} } + +const Default_CMsgExtractGems_ItemSocketId uint32 = 65535 + +func (m *CMsgExtractGems) GetToolItemId() uint64 { + if m != nil && m.ToolItemId != nil { + return *m.ToolItemId + } + return 0 +} + +func (m *CMsgExtractGems) GetItemItemId() uint64 { + if m != nil && m.ItemItemId != nil { + return *m.ItemItemId + } + return 0 +} + +func (m *CMsgExtractGems) GetItemSocketId() uint32 { + if m != nil && m.ItemSocketId != nil { + return *m.ItemSocketId + } + return Default_CMsgExtractGems_ItemSocketId +} + +type CMsgExtractGemsResponse struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + Response *CMsgExtractGemsResponse_EExtractGems `protobuf:"varint,2,opt,name=response,enum=CMsgExtractGemsResponse_EExtractGems,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgExtractGemsResponse) Reset() { *m = CMsgExtractGemsResponse{} } +func (m *CMsgExtractGemsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgExtractGemsResponse) ProtoMessage() {} +func (*CMsgExtractGemsResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{78} } + +const Default_CMsgExtractGemsResponse_Response CMsgExtractGemsResponse_EExtractGems = CMsgExtractGemsResponse_k_ExtractGems_Succeeded + +func (m *CMsgExtractGemsResponse) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgExtractGemsResponse) GetResponse() CMsgExtractGemsResponse_EExtractGems { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgExtractGemsResponse_Response +} + +type CMsgAddSocket struct { + ToolItemId *uint64 `protobuf:"varint,1,opt,name=tool_item_id" json:"tool_item_id,omitempty"` + ItemItemId *uint64 `protobuf:"varint,2,opt,name=item_item_id" json:"item_item_id,omitempty"` + Unusual *bool `protobuf:"varint,3,opt,name=unusual" json:"unusual,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAddSocket) Reset() { *m = CMsgAddSocket{} } +func (m *CMsgAddSocket) String() string { return proto.CompactTextString(m) } +func (*CMsgAddSocket) ProtoMessage() {} +func (*CMsgAddSocket) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{79} } + +func (m *CMsgAddSocket) GetToolItemId() uint64 { + if m != nil && m.ToolItemId != nil { + return *m.ToolItemId + } + return 0 +} + +func (m *CMsgAddSocket) GetItemItemId() uint64 { + if m != nil && m.ItemItemId != nil { + return *m.ItemItemId + } + return 0 +} + +func (m *CMsgAddSocket) GetUnusual() bool { + if m != nil && m.Unusual != nil { + return *m.Unusual + } + return false +} + +type CMsgAddSocketResponse struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + UpdatedSocketIndex []uint32 `protobuf:"varint,2,rep,name=updated_socket_index" json:"updated_socket_index,omitempty"` + Response *CMsgAddSocketResponse_EAddSocket `protobuf:"varint,3,opt,name=response,enum=CMsgAddSocketResponse_EAddSocket,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAddSocketResponse) Reset() { *m = CMsgAddSocketResponse{} } +func (m *CMsgAddSocketResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgAddSocketResponse) ProtoMessage() {} +func (*CMsgAddSocketResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{80} } + +const Default_CMsgAddSocketResponse_Response CMsgAddSocketResponse_EAddSocket = CMsgAddSocketResponse_k_AddSocket_Succeeded + +func (m *CMsgAddSocketResponse) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgAddSocketResponse) GetUpdatedSocketIndex() []uint32 { + if m != nil { + return m.UpdatedSocketIndex + } + return nil +} + +func (m *CMsgAddSocketResponse) GetResponse() CMsgAddSocketResponse_EAddSocket { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgAddSocketResponse_Response +} + +type CMsgAddItemToSocketData struct { + GemItemId *uint64 `protobuf:"varint,1,opt,name=gem_item_id" json:"gem_item_id,omitempty"` + SocketIndex *uint32 `protobuf:"varint,2,opt,name=socket_index" json:"socket_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAddItemToSocketData) Reset() { *m = CMsgAddItemToSocketData{} } +func (m *CMsgAddItemToSocketData) String() string { return proto.CompactTextString(m) } +func (*CMsgAddItemToSocketData) ProtoMessage() {} +func (*CMsgAddItemToSocketData) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{81} } + +func (m *CMsgAddItemToSocketData) GetGemItemId() uint64 { + if m != nil && m.GemItemId != nil { + return *m.GemItemId + } + return 0 +} + +func (m *CMsgAddItemToSocketData) GetSocketIndex() uint32 { + if m != nil && m.SocketIndex != nil { + return *m.SocketIndex + } + return 0 +} + +type CMsgAddItemToSocket struct { + ItemItemId *uint64 `protobuf:"varint,1,opt,name=item_item_id" json:"item_item_id,omitempty"` + GemsToSocket []*CMsgAddItemToSocketData `protobuf:"bytes,2,rep,name=gems_to_socket" json:"gems_to_socket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAddItemToSocket) Reset() { *m = CMsgAddItemToSocket{} } +func (m *CMsgAddItemToSocket) String() string { return proto.CompactTextString(m) } +func (*CMsgAddItemToSocket) ProtoMessage() {} +func (*CMsgAddItemToSocket) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{82} } + +func (m *CMsgAddItemToSocket) GetItemItemId() uint64 { + if m != nil && m.ItemItemId != nil { + return *m.ItemItemId + } + return 0 +} + +func (m *CMsgAddItemToSocket) GetGemsToSocket() []*CMsgAddItemToSocketData { + if m != nil { + return m.GemsToSocket + } + return nil +} + +type CMsgAddItemToSocketResponse struct { + ItemItemId *uint64 `protobuf:"varint,1,opt,name=item_item_id" json:"item_item_id,omitempty"` + UpdatedSocketIndex []uint32 `protobuf:"varint,2,rep,name=updated_socket_index" json:"updated_socket_index,omitempty"` + Response *CMsgAddItemToSocketResponse_EAddGem `protobuf:"varint,3,opt,name=response,enum=CMsgAddItemToSocketResponse_EAddGem,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAddItemToSocketResponse) Reset() { *m = CMsgAddItemToSocketResponse{} } +func (m *CMsgAddItemToSocketResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgAddItemToSocketResponse) ProtoMessage() {} +func (*CMsgAddItemToSocketResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{83} } + +const Default_CMsgAddItemToSocketResponse_Response CMsgAddItemToSocketResponse_EAddGem = CMsgAddItemToSocketResponse_k_AddGem_Succeeded + +func (m *CMsgAddItemToSocketResponse) GetItemItemId() uint64 { + if m != nil && m.ItemItemId != nil { + return *m.ItemItemId + } + return 0 +} + +func (m *CMsgAddItemToSocketResponse) GetUpdatedSocketIndex() []uint32 { + if m != nil { + return m.UpdatedSocketIndex + } + return nil +} + +func (m *CMsgAddItemToSocketResponse) GetResponse() CMsgAddItemToSocketResponse_EAddGem { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgAddItemToSocketResponse_Response +} + +type CMsgResetStrangeGemCount struct { + ItemItemId *uint64 `protobuf:"varint,1,opt,name=item_item_id" json:"item_item_id,omitempty"` + SocketIndex *uint32 `protobuf:"varint,2,opt,name=socket_index" json:"socket_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgResetStrangeGemCount) Reset() { *m = CMsgResetStrangeGemCount{} } +func (m *CMsgResetStrangeGemCount) String() string { return proto.CompactTextString(m) } +func (*CMsgResetStrangeGemCount) ProtoMessage() {} +func (*CMsgResetStrangeGemCount) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{84} } + +func (m *CMsgResetStrangeGemCount) GetItemItemId() uint64 { + if m != nil && m.ItemItemId != nil { + return *m.ItemItemId + } + return 0 +} + +func (m *CMsgResetStrangeGemCount) GetSocketIndex() uint32 { + if m != nil && m.SocketIndex != nil { + return *m.SocketIndex + } + return 0 +} + +type CMsgResetStrangeGemCountResponse struct { + Response *CMsgResetStrangeGemCountResponse_EResetGem `protobuf:"varint,1,opt,name=response,enum=CMsgResetStrangeGemCountResponse_EResetGem,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgResetStrangeGemCountResponse) Reset() { *m = CMsgResetStrangeGemCountResponse{} } +func (m *CMsgResetStrangeGemCountResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgResetStrangeGemCountResponse) ProtoMessage() {} +func (*CMsgResetStrangeGemCountResponse) Descriptor() ([]byte, []int) { + return base_fileDescriptor0, []int{85} +} + +const Default_CMsgResetStrangeGemCountResponse_Response CMsgResetStrangeGemCountResponse_EResetGem = CMsgResetStrangeGemCountResponse_k_ResetGem_Succeeded + +func (m *CMsgResetStrangeGemCountResponse) GetResponse() CMsgResetStrangeGemCountResponse_EResetGem { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgResetStrangeGemCountResponse_Response +} + +func init() { + proto.RegisterType((*CGCStorePurchaseInit_LineItem)(nil), "CGCStorePurchaseInit_LineItem") + proto.RegisterType((*CMsgGCStorePurchaseInit)(nil), "CMsgGCStorePurchaseInit") + proto.RegisterType((*CMsgGCStorePurchaseInitResponse)(nil), "CMsgGCStorePurchaseInitResponse") + proto.RegisterType((*CMsgSystemBroadcast)(nil), "CMsgSystemBroadcast") + proto.RegisterType((*CMsgClientPingData)(nil), "CMsgClientPingData") + proto.RegisterType((*CMsgInviteToParty)(nil), "CMsgInviteToParty") + proto.RegisterType((*CMsgInviteToLobby)(nil), "CMsgInviteToLobby") + proto.RegisterType((*CMsgInvitationCreated)(nil), "CMsgInvitationCreated") + proto.RegisterType((*CMsgPartyInviteResponse)(nil), "CMsgPartyInviteResponse") + proto.RegisterType((*CMsgLobbyInviteResponse)(nil), "CMsgLobbyInviteResponse") + proto.RegisterType((*CMsgKickFromParty)(nil), "CMsgKickFromParty") + proto.RegisterType((*CMsgLeaveParty)(nil), "CMsgLeaveParty") + proto.RegisterType((*CMsgCustomGameInstallStatus)(nil), "CMsgCustomGameInstallStatus") + proto.RegisterType((*CMsgServerAvailable)(nil), "CMsgServerAvailable") + proto.RegisterType((*CMsgLANServerAvailable)(nil), "CMsgLANServerAvailable") + proto.RegisterType((*CSOEconGameAccountClient)(nil), "CSOEconGameAccountClient") + proto.RegisterType((*CSOItemCriteriaCondition)(nil), "CSOItemCriteriaCondition") + proto.RegisterType((*CSOItemCriteria)(nil), "CSOItemCriteria") + proto.RegisterType((*CSOItemRecipe)(nil), "CSOItemRecipe") + proto.RegisterType((*CMsgApplyStrangePart)(nil), "CMsgApplyStrangePart") + proto.RegisterType((*CMsgApplyPennantUpgrade)(nil), "CMsgApplyPennantUpgrade") + proto.RegisterType((*CMsgApplyEggEssence)(nil), "CMsgApplyEggEssence") + proto.RegisterType((*CSOEconItemAttribute)(nil), "CSOEconItemAttribute") + proto.RegisterType((*CSOEconItemEquipped)(nil), "CSOEconItemEquipped") + proto.RegisterType((*CSOEconItem)(nil), "CSOEconItem") + proto.RegisterType((*CMsgSortItems)(nil), "CMsgSortItems") + proto.RegisterType((*CSOEconClaimCode)(nil), "CSOEconClaimCode") + proto.RegisterType((*CMsgStoreGetUserData)(nil), "CMsgStoreGetUserData") + proto.RegisterType((*CMsgStoreGetUserDataResponse)(nil), "CMsgStoreGetUserDataResponse") + proto.RegisterType((*CMsgUpdateItemSchema)(nil), "CMsgUpdateItemSchema") + proto.RegisterType((*CMsgGCError)(nil), "CMsgGCError") + proto.RegisterType((*CMsgRequestInventoryRefresh)(nil), "CMsgRequestInventoryRefresh") + proto.RegisterType((*CMsgConVarValue)(nil), "CMsgConVarValue") + proto.RegisterType((*CMsgReplicateConVars)(nil), "CMsgReplicateConVars") + proto.RegisterType((*CMsgReplayUploadedToYouTube)(nil), "CMsgReplayUploadedToYouTube") + proto.RegisterType((*CMsgConsumableExhausted)(nil), "CMsgConsumableExhausted") + proto.RegisterType((*CMsgItemAcknowledged)(nil), "CMsgItemAcknowledged") + proto.RegisterType((*CMsgSetPresetItemPosition)(nil), "CMsgSetPresetItemPosition") + proto.RegisterType((*CMsgSetItemPositions)(nil), "CMsgSetItemPositions") + proto.RegisterType((*CMsgSetItemPositions_ItemPosition)(nil), "CMsgSetItemPositions.ItemPosition") + proto.RegisterType((*CSOEconItemPresetInstance)(nil), "CSOEconItemPresetInstance") + proto.RegisterType((*CMsgSelectItemPresetForClass)(nil), "CMsgSelectItemPresetForClass") + proto.RegisterType((*CMsgSelectItemPresetForClassReply)(nil), "CMsgSelectItemPresetForClassReply") + proto.RegisterType((*CSOSelectedItemPreset)(nil), "CSOSelectedItemPreset") + proto.RegisterType((*CMsgGCNameItemNotification)(nil), "CMsgGCNameItemNotification") + proto.RegisterType((*CMsgGCClientDisplayNotification)(nil), "CMsgGCClientDisplayNotification") + proto.RegisterType((*CMsgGCShowItemsPickedUp)(nil), "CMsgGCShowItemsPickedUp") + proto.RegisterType((*CMsgGCIncrementKillCountResponse)(nil), "CMsgGCIncrementKillCountResponse") + proto.RegisterType((*CSOEconItemDropRateBonus)(nil), "CSOEconItemDropRateBonus") + proto.RegisterType((*CSOEconItemLeagueViewPass)(nil), "CSOEconItemLeagueViewPass") + proto.RegisterType((*CSOEconItemEventTicket)(nil), "CSOEconItemEventTicket") + proto.RegisterType((*CSOEconItemTournamentPassport)(nil), "CSOEconItemTournamentPassport") + proto.RegisterType((*CMsgGCItemPreviewItemBoughtNotification)(nil), "CMsgGCItemPreviewItemBoughtNotification") + proto.RegisterType((*CMsgGCStorePurchaseCancel)(nil), "CMsgGCStorePurchaseCancel") + proto.RegisterType((*CMsgGCStorePurchaseCancelResponse)(nil), "CMsgGCStorePurchaseCancelResponse") + proto.RegisterType((*CMsgGCStorePurchaseFinalize)(nil), "CMsgGCStorePurchaseFinalize") + proto.RegisterType((*CMsgGCStorePurchaseFinalizeResponse)(nil), "CMsgGCStorePurchaseFinalizeResponse") + proto.RegisterType((*CMsgGCBannedWordListRequest)(nil), "CMsgGCBannedWordListRequest") + proto.RegisterType((*CMsgGCBannedWord)(nil), "CMsgGCBannedWord") + proto.RegisterType((*CMsgGCBannedWordListResponse)(nil), "CMsgGCBannedWordListResponse") + proto.RegisterType((*CMsgGCToGCBannedWordListBroadcast)(nil), "CMsgGCToGCBannedWordListBroadcast") + proto.RegisterType((*CMsgGCToGCBannedWordListUpdated)(nil), "CMsgGCToGCBannedWordListUpdated") + proto.RegisterType((*CMsgGCToGCDirtySDOCache)(nil), "CMsgGCToGCDirtySDOCache") + proto.RegisterType((*CMsgGCToGCDirtyMultipleSDOCache)(nil), "CMsgGCToGCDirtyMultipleSDOCache") + proto.RegisterType((*CMsgGCToGCApplyLocalizationDiff)(nil), "CMsgGCToGCApplyLocalizationDiff") + proto.RegisterType((*CMsgGCToGCApplyLocalizationDiffResponse)(nil), "CMsgGCToGCApplyLocalizationDiffResponse") + proto.RegisterType((*CMsgGCCollectItem)(nil), "CMsgGCCollectItem") + proto.RegisterType((*CMsgSDONoMemcached)(nil), "CMsgSDONoMemcached") + proto.RegisterType((*CMsgGCToGCUpdateSQLKeyValue)(nil), "CMsgGCToGCUpdateSQLKeyValue") + proto.RegisterType((*CMsgGCToGCBroadcastConsoleCommand)(nil), "CMsgGCToGCBroadcastConsoleCommand") + proto.RegisterType((*CMsgGCServerVersionUpdated)(nil), "CMsgGCServerVersionUpdated") + proto.RegisterType((*CMsgGCClientVersionUpdated)(nil), "CMsgGCClientVersionUpdated") + proto.RegisterType((*CMsgGCToGCWebAPIAccountChanged)(nil), "CMsgGCToGCWebAPIAccountChanged") + proto.RegisterType((*CMsgRecipeComponent)(nil), "CMsgRecipeComponent") + proto.RegisterType((*CMsgFulfillDynamicRecipeComponent)(nil), "CMsgFulfillDynamicRecipeComponent") + proto.RegisterType((*CMsgGCClientMarketDataRequest)(nil), "CMsgGCClientMarketDataRequest") + proto.RegisterType((*CMsgGCClientMarketDataEntry)(nil), "CMsgGCClientMarketDataEntry") + proto.RegisterType((*CMsgGCClientMarketData)(nil), "CMsgGCClientMarketData") + proto.RegisterType((*CMsgExtractGems)(nil), "CMsgExtractGems") + proto.RegisterType((*CMsgExtractGemsResponse)(nil), "CMsgExtractGemsResponse") + proto.RegisterType((*CMsgAddSocket)(nil), "CMsgAddSocket") + proto.RegisterType((*CMsgAddSocketResponse)(nil), "CMsgAddSocketResponse") + proto.RegisterType((*CMsgAddItemToSocketData)(nil), "CMsgAddItemToSocketData") + proto.RegisterType((*CMsgAddItemToSocket)(nil), "CMsgAddItemToSocket") + proto.RegisterType((*CMsgAddItemToSocketResponse)(nil), "CMsgAddItemToSocketResponse") + proto.RegisterType((*CMsgResetStrangeGemCount)(nil), "CMsgResetStrangeGemCount") + proto.RegisterType((*CMsgResetStrangeGemCountResponse)(nil), "CMsgResetStrangeGemCountResponse") + proto.RegisterEnum("EGCBaseMsg", EGCBaseMsg_name, EGCBaseMsg_value) + proto.RegisterEnum("EGCBaseProtoObjectTypes", EGCBaseProtoObjectTypes_name, EGCBaseProtoObjectTypes_value) + proto.RegisterEnum("ECustomGameInstallStatus", ECustomGameInstallStatus_name, ECustomGameInstallStatus_value) + proto.RegisterEnum("GC_BannedWordType", GC_BannedWordType_name, GC_BannedWordType_value) + proto.RegisterEnum("CMsgExtractGemsResponse_EExtractGems", CMsgExtractGemsResponse_EExtractGems_name, CMsgExtractGemsResponse_EExtractGems_value) + proto.RegisterEnum("CMsgAddSocketResponse_EAddSocket", CMsgAddSocketResponse_EAddSocket_name, CMsgAddSocketResponse_EAddSocket_value) + proto.RegisterEnum("CMsgAddItemToSocketResponse_EAddGem", CMsgAddItemToSocketResponse_EAddGem_name, CMsgAddItemToSocketResponse_EAddGem_value) + proto.RegisterEnum("CMsgResetStrangeGemCountResponse_EResetGem", CMsgResetStrangeGemCountResponse_EResetGem_name, CMsgResetStrangeGemCountResponse_EResetGem_value) +} + +var base_fileDescriptor0 = []byte{ + // 4164 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x5a, 0xdd, 0x6f, 0xe4, 0x58, + 0x56, 0xdf, 0xaa, 0x4a, 0xa5, 0x92, 0x9b, 0x8f, 0x71, 0x9c, 0xa4, 0x53, 0xfd, 0xdd, 0xed, 0xea, + 0xe9, 0xed, 0xed, 0x99, 0xa9, 0x9d, 0xe9, 0xe9, 0x19, 0x20, 0x12, 0x82, 0xa4, 0x92, 0xce, 0x64, + 0xa7, 0x3f, 0xb2, 0x49, 0x7a, 0x46, 0x2b, 0x01, 0x96, 0xcb, 0xbe, 0x55, 0xf1, 0xc6, 0x65, 0x7b, + 0xfd, 0x91, 0x4e, 0x2d, 0x3c, 0x2c, 0x20, 0x24, 0x24, 0x5e, 0xf9, 0x5c, 0x60, 0x61, 0x17, 0xc4, + 0x9f, 0x80, 0xc4, 0x0b, 0xbc, 0x20, 0x21, 0x21, 0xf1, 0xc6, 0x3e, 0xf3, 0x0a, 0xbc, 0x20, 0xfe, + 0x03, 0xce, 0x39, 0xf7, 0x5e, 0xdb, 0xe5, 0x2a, 0xa7, 0x67, 0x78, 0x88, 0x52, 0xbe, 0xf7, 0xdc, + 0x73, 0xcf, 0x3d, 0x1f, 0xbf, 0x73, 0xce, 0xb5, 0xd9, 0x66, 0xdf, 0x8a, 0xb9, 0x39, 0xb4, 0x47, + 0x3c, 0x8e, 0xad, 0x21, 0x8f, 0xbb, 0x61, 0x14, 0x24, 0xc1, 0x8d, 0xf5, 0x38, 0xe1, 0xd6, 0x68, + 0x72, 0xd0, 0xf8, 0x71, 0x8d, 0xdd, 0xee, 0x1d, 0xf4, 0x4e, 0x92, 0x20, 0xe2, 0x47, 0x69, 0x64, + 0x9f, 0xc1, 0xd2, 0x43, 0xdf, 0x4d, 0xcc, 0xe7, 0xae, 0xcf, 0x0f, 0x13, 0x3e, 0xd2, 0xd7, 0xd9, + 0x92, 0x0b, 0xff, 0x4d, 0x87, 0x0f, 0x4c, 0xd7, 0x69, 0xd7, 0xee, 0xd5, 0x1e, 0xad, 0xe8, 0x1a, + 0x5b, 0xf8, 0x41, 0x6a, 0xf9, 0x89, 0x9b, 0x8c, 0xdb, 0x75, 0x1a, 0xb9, 0xc3, 0xae, 0xd9, 0x41, + 0x9c, 0x98, 0xae, 0x6f, 0x7a, 0x81, 0x6d, 0x79, 0xa6, 0x9d, 0x46, 0x11, 0xf7, 0xed, 0x71, 0xbb, + 0x41, 0xf3, 0x9b, 0x6c, 0x25, 0x94, 0xfc, 0xcd, 0x64, 0x1c, 0xf2, 0xf6, 0x1c, 0x0d, 0xdf, 0x64, + 0xeb, 0x71, 0x00, 0xe3, 0xdc, 0x8c, 0xf8, 0x80, 0xe3, 0x02, 0x8e, 0xbb, 0x34, 0x61, 0x72, 0xce, + 0xf8, 0x9d, 0x1a, 0xdb, 0xea, 0xbd, 0x88, 0x87, 0x33, 0xe4, 0xd3, 0xdf, 0x61, 0x2d, 0x3b, 0x48, + 0xfd, 0x24, 0x1a, 0x93, 0x48, 0x8b, 0x28, 0x92, 0x67, 0xf9, 0xc3, 0x14, 0x0e, 0x47, 0x22, 0x35, + 0x71, 0x64, 0x42, 0x88, 0xa6, 0xfe, 0x84, 0x31, 0x0f, 0xce, 0x65, 0xe2, 0x81, 0x62, 0x90, 0xa0, + 0xf1, 0x68, 0xe9, 0xc9, 0x9d, 0xee, 0x95, 0xe7, 0x37, 0x76, 0xd8, 0xdd, 0x0a, 0x19, 0x8e, 0x79, + 0x1c, 0x06, 0x7e, 0xcc, 0xf5, 0x55, 0x36, 0x1f, 0xf1, 0x38, 0xf5, 0x12, 0x12, 0xa5, 0x89, 0xcf, + 0xc9, 0xa5, 0x8f, 0xe7, 0xa8, 0xd3, 0x39, 0x1e, 0xb2, 0x75, 0x64, 0x71, 0x32, 0x06, 0x0b, 0x8c, + 0x76, 0xa3, 0xc0, 0x72, 0x6c, 0x2b, 0xa6, 0x23, 0x48, 0x6b, 0x88, 0x23, 0x18, 0x3f, 0xa9, 0x31, + 0x1d, 0x09, 0x7b, 0x9e, 0xcb, 0xfd, 0xe4, 0xc8, 0xf5, 0x87, 0x7b, 0x56, 0x62, 0xe9, 0x5b, 0x6c, + 0x29, 0xe2, 0x9e, 0x35, 0x36, 0xed, 0xc0, 0xe1, 0x42, 0xec, 0xd6, 0x6e, 0x5d, 0xab, 0xe5, 0x13, + 0x21, 0x90, 0xc6, 0xa0, 0xb4, 0xc6, 0xa3, 0x15, 0x9a, 0x68, 0xb3, 0xe5, 0x88, 0x0f, 0xdd, 0xc0, + 0x97, 0x4b, 0x16, 0x66, 0xcc, 0x88, 0x35, 0x8b, 0xd9, 0x8c, 0xc1, 0x6e, 0x14, 0x66, 0xcc, 0x81, + 0xe5, 0x7a, 0xdc, 0x31, 0xfb, 0x6e, 0x32, 0xb2, 0xe2, 0xf3, 0x36, 0x43, 0x6b, 0x19, 0xbf, 0x5f, + 0x63, 0x6b, 0x28, 0xe0, 0xa1, 0x7f, 0x01, 0x2a, 0x3c, 0x0d, 0x8e, 0xac, 0x28, 0x19, 0xa3, 0x9e, + 0xc9, 0xb5, 0x94, 0x7b, 0xcc, 0xeb, 0xd7, 0xd8, 0xaa, 0x4d, 0x67, 0x30, 0x2f, 0x78, 0x14, 0x03, + 0x4f, 0xe9, 0x24, 0x70, 0x62, 0x45, 0xd8, 0x50, 0x7e, 0x64, 0xc5, 0x20, 0xa4, 0x65, 0x9f, 0x91, + 0x43, 0x2c, 0xe8, 0x0f, 0xd9, 0x22, 0xed, 0xef, 0xc0, 0xc9, 0xc9, 0x0d, 0x96, 0x9e, 0xac, 0x77, + 0xa7, 0x95, 0x62, 0xfc, 0xf2, 0xa4, 0x24, 0xcf, 0x83, 0x7e, 0xff, 0x6b, 0x48, 0x62, 0x7c, 0x97, + 0x6d, 0x66, 0xcb, 0xad, 0x04, 0xc6, 0x7b, 0x11, 0xb7, 0x12, 0xee, 0x20, 0x8b, 0x61, 0x14, 0xa4, + 0xa1, 0x62, 0x31, 0x37, 0xc1, 0xb4, 0x4e, 0x4c, 0x37, 0xd8, 0x72, 0x1a, 0xf3, 0xc8, 0x0c, 0x06, + 0x03, 0x74, 0x27, 0x3a, 0xcb, 0x82, 0xf1, 0x9b, 0xc2, 0x59, 0x49, 0x27, 0x42, 0xac, 0xcc, 0x41, + 0x80, 0x45, 0x88, 0xc3, 0x39, 0x53, 0x70, 0x11, 0xcb, 0xb6, 0x79, 0x98, 0x10, 0xcb, 0x85, 0x19, + 0x72, 0x0a, 0x05, 0x4d, 0xa8, 0x63, 0xa1, 0x5a, 0x1d, 0x7f, 0x20, 0x43, 0x85, 0xf4, 0x30, 0xbd, + 0xbb, 0x87, 0xc3, 0xb9, 0x56, 0xbe, 0xea, 0xee, 0x5b, 0xec, 0x1d, 0x3b, 0x8d, 0x93, 0x60, 0x64, + 0x0e, 0xad, 0x11, 0x37, 0xed, 0xc8, 0x6e, 0xcf, 0x13, 0x83, 0xdb, 0x6c, 0xb3, 0x38, 0x91, 0xb8, + 0xe0, 0xc8, 0x89, 0x35, 0x0a, 0xdb, 0x2d, 0x98, 0x6e, 0x19, 0xef, 0x0a, 0xe3, 0x7c, 0xee, 0xda, + 0xe7, 0xcf, 0xa2, 0x60, 0x54, 0xe1, 0x26, 0x86, 0xc6, 0x56, 0x49, 0x66, 0x6e, 0x5d, 0x70, 0xa2, + 0x31, 0x7e, 0x56, 0x63, 0x37, 0xe9, 0x74, 0xc4, 0xfc, 0x00, 0x78, 0x1f, 0xfa, 0xc0, 0xd8, 0xf3, + 0x4e, 0xc0, 0x4a, 0x69, 0xac, 0xbf, 0x60, 0xf3, 0x31, 0xfd, 0x22, 0x0e, 0xab, 0x4f, 0xae, 0x77, + 0xf7, 0x2b, 0x48, 0xb7, 0x8d, 0x73, 0xb3, 0x6a, 0xce, 0x7c, 0xed, 0x9f, 0xfb, 0xc1, 0x1b, 0xbf, + 0x18, 0x81, 0x75, 0x02, 0x91, 0x0e, 0xbb, 0xe9, 0x81, 0x1b, 0x00, 0x8e, 0x65, 0x47, 0x32, 0x07, + 0x70, 0x02, 0x93, 0x24, 0x27, 0xad, 0xb4, 0x8c, 0x2f, 0x65, 0x38, 0xf3, 0x08, 0xb4, 0xb5, 0x73, + 0x01, 0x81, 0x62, 0xf5, 0x3d, 0xae, 0xff, 0x2a, 0xbb, 0x51, 0xd4, 0x89, 0x2b, 0x76, 0x34, 0x0b, + 0xf2, 0x2e, 0x3d, 0xb9, 0xd5, 0xbd, 0xe2, 0x74, 0xc6, 0x63, 0x76, 0x8d, 0xf4, 0xb1, 0xf3, 0xb2, + 0xcc, 0x7b, 0xca, 0x84, 0xc6, 0xbf, 0xd4, 0x59, 0xbb, 0x77, 0xf2, 0x6a, 0xdf, 0x0e, 0x7c, 0x64, + 0xb4, 0x63, 0x13, 0x1a, 0x0a, 0xaf, 0xd0, 0x1f, 0xb0, 0xeb, 0x96, 0xe3, 0xb8, 0xe8, 0xd7, 0x80, + 0xc4, 0x7d, 0xcb, 0x3e, 0x0f, 0xe1, 0xcf, 0x8c, 0xbd, 0x20, 0x11, 0x92, 0xac, 0x6c, 0xd7, 0x3e, + 0xd4, 0x6f, 0xb1, 0x95, 0x24, 0x72, 0x81, 0xc0, 0x12, 0x8b, 0x85, 0x33, 0x6c, 0x37, 0x07, 0x96, + 0x07, 0x5e, 0xf3, 0x90, 0xb5, 0xb9, 0xe7, 0x0e, 0x5d, 0xd8, 0xde, 0x1c, 0x04, 0xe0, 0xec, 0x3e, + 0x41, 0x67, 0x08, 0x78, 0x23, 0x1c, 0x7e, 0x7b, 0x2e, 0x89, 0x52, 0xae, 0x3f, 0x66, 0x86, 0xcf, + 0x01, 0x29, 0x92, 0xc0, 0xb4, 0xcf, 0x82, 0x00, 0xe0, 0x7d, 0x84, 0x79, 0xe0, 0x8c, 0x7b, 0xe1, + 0x20, 0xf5, 0x40, 0x7b, 0x20, 0x91, 0x23, 0x83, 0x1b, 0xfc, 0xc9, 0xf5, 0x45, 0xb8, 0xf3, 0xd8, + 0xf4, 0xdc, 0x38, 0xa1, 0x10, 0x5f, 0x00, 0x51, 0x36, 0x92, 0xc8, 0x72, 0x38, 0xc8, 0xea, 0x9b, + 0xfc, 0x32, 0x74, 0x23, 0x0a, 0x4a, 0xf2, 0xb6, 0x16, 0x26, 0x09, 0x27, 0xe5, 0x5e, 0x79, 0xb2, + 0x25, 0x27, 0xb5, 0x30, 0xe2, 0x17, 0x2e, 0x7f, 0x63, 0xaa, 0x3c, 0x45, 0x81, 0x42, 0x47, 0x34, + 0xd8, 0xfa, 0x08, 0xd9, 0x0e, 0xdc, 0x08, 0x64, 0x52, 0x09, 0x08, 0x50, 0x2f, 0x3f, 0xa8, 0x11, + 0x91, 0x22, 0x11, 0xeb, 0x7b, 0x11, 0x70, 0x00, 0x8d, 0xf4, 0x02, 0x5f, 0x28, 0x4f, 0x67, 0xac, + 0x1e, 0x84, 0x12, 0xd5, 0x57, 0x58, 0x73, 0xe0, 0x72, 0xcf, 0x91, 0xae, 0x02, 0x26, 0x89, 0xf8, + 0x0f, 0x52, 0x37, 0xe2, 0x02, 0xcc, 0x16, 0x30, 0x53, 0x0e, 0xbc, 0xc0, 0x82, 0x20, 0xb2, 0xbc, + 0x54, 0x24, 0xb8, 0x3a, 0x62, 0x45, 0x0c, 0x5a, 0x86, 0x10, 0x16, 0xa3, 0x4d, 0x42, 0xfa, 0xdf, + 0xad, 0xb3, 0x77, 0x4a, 0x9b, 0xea, 0xb0, 0x19, 0x1d, 0xc0, 0xe3, 0x17, 0xdc, 0x93, 0x79, 0x16, + 0x56, 0xd3, 0x18, 0x24, 0x5b, 0x4f, 0xe5, 0xda, 0x26, 0x86, 0x6b, 0x4e, 0x69, 0xc6, 0x3c, 0x91, + 0x02, 0xb4, 0x99, 0x56, 0xa4, 0xa6, 0x19, 0xa1, 0xf8, 0xeb, 0x6c, 0xcd, 0x85, 0x8c, 0x85, 0xc6, + 0x76, 0xfd, 0x0b, 0x70, 0x91, 0x00, 0xf2, 0x66, 0x93, 0xb6, 0xc0, 0x45, 0x72, 0x2a, 0x4b, 0xe9, + 0xf3, 0x2a, 0x37, 0xbb, 0x43, 0x1f, 0x92, 0x9e, 0xc9, 0x7d, 0xf4, 0x42, 0xc7, 0x1c, 0x78, 0xd6, + 0x90, 0x94, 0xbb, 0xa0, 0x7f, 0xc0, 0x98, 0xad, 0xd4, 0x24, 0xd2, 0xc8, 0x12, 0x44, 0x63, 0xa5, + 0x22, 0xd7, 0x31, 0x55, 0xd9, 0x88, 0x30, 0xe0, 0x47, 0x63, 0x4a, 0x27, 0x0b, 0xc6, 0xcf, 0x1b, + 0x6c, 0x45, 0xae, 0x38, 0xe6, 0xb6, 0x1b, 0x72, 0x7d, 0x8d, 0x2d, 0x52, 0x9d, 0xe1, 0x3b, 0xfc, + 0x52, 0xaa, 0x60, 0x99, 0xcd, 0xf9, 0xe0, 0xe0, 0x52, 0xeb, 0x4b, 0xac, 0xe1, 0x9b, 0x16, 0x9d, + 0x77, 0x11, 0x99, 0x42, 0x76, 0xb3, 0x81, 0x3c, 0x4c, 0x93, 0x98, 0x8e, 0xba, 0x88, 0x2a, 0xa3, + 0xc1, 0x20, 0x4d, 0x68, 0x94, 0x14, 0x8e, 0x5c, 0x1c, 0x17, 0x16, 0xce, 0x17, 0x9e, 0xfa, 0xe4, + 0x41, 0xea, 0xc9, 0xa6, 0x83, 0x89, 0xa7, 0x00, 0x28, 0x17, 0x0b, 0x4f, 0x7d, 0x12, 0x58, 0x3d, + 0xd9, 0xed, 0x25, 0x7a, 0xba, 0xcb, 0xb6, 0xa4, 0x07, 0xc4, 0x26, 0x45, 0x3a, 0x61, 0xa4, 0x67, + 0xc5, 0x71, 0x7b, 0x99, 0x74, 0x04, 0x35, 0xd1, 0x34, 0x01, 0x06, 0x61, 0x7b, 0x45, 0xcd, 0x13, + 0xb9, 0x99, 0x22, 0x04, 0x89, 0x28, 0x23, 0xa9, 0xdb, 0xab, 0x64, 0x67, 0x40, 0x59, 0xa4, 0x9e, + 0x9e, 0x7e, 0x47, 0xb9, 0x01, 0x58, 0xb8, 0x38, 0xae, 0xd1, 0x78, 0x97, 0x6d, 0x90, 0x46, 0x44, + 0x99, 0x03, 0xa8, 0x2d, 0x8c, 0xd1, 0xde, 0x20, 0x23, 0x69, 0x65, 0x23, 0xe9, 0xdf, 0x66, 0x9b, + 0x62, 0x7d, 0x79, 0xc1, 0x66, 0xc5, 0x02, 0x90, 0x3b, 0xdf, 0xc0, 0x74, 0xd2, 0x10, 0x8e, 0x8d, + 0x00, 0x12, 0xb7, 0xaf, 0x61, 0x39, 0x61, 0x7c, 0x87, 0x6d, 0x20, 0x8e, 0xed, 0x84, 0xa1, 0x37, + 0x3e, 0x81, 0xb8, 0xf6, 0x87, 0x04, 0xef, 0x18, 0xe5, 0xb1, 0x78, 0x34, 0x31, 0x1d, 0x8a, 0xe5, + 0x59, 0x4a, 0x54, 0xbe, 0xae, 0x46, 0x45, 0xed, 0xf4, 0xb9, 0xc8, 0x6b, 0xc4, 0xeb, 0x88, 0xfb, + 0x3e, 0x78, 0xe8, 0xeb, 0x70, 0x88, 0x58, 0x81, 0x68, 0x92, 0x8a, 0x9f, 0x25, 0x4e, 0x30, 0x11, + 0x0a, 0xd2, 0x12, 0xb3, 0x9e, 0x40, 0x6e, 0x62, 0xb6, 0x3f, 0x1c, 0xee, 0xc7, 0x31, 0x16, 0x9c, + 0x48, 0xcf, 0xc5, 0xcf, 0x12, 0x23, 0x70, 0x30, 0x3e, 0x1c, 0x96, 0x98, 0xbc, 0x80, 0xd3, 0x09, + 0xe0, 0x45, 0xa5, 0xec, 0x24, 0x10, 0xdd, 0xfd, 0x34, 0x99, 0xe9, 0xbb, 0x00, 0x19, 0x22, 0xea, + 0x45, 0xf9, 0x03, 0xec, 0xe8, 0xd1, 0xec, 0x8f, 0x21, 0xc7, 0x90, 0x13, 0x2f, 0x1b, 0xdb, 0x20, + 0x53, 0xce, 0x6e, 0x1f, 0xdc, 0x25, 0x0c, 0xa1, 0x0e, 0x01, 0x6e, 0x3e, 0x40, 0x9a, 0x70, 0xa7, + 0xac, 0xe8, 0xc6, 0x21, 0x72, 0x20, 0x51, 0xc5, 0xfc, 0x6f, 0x9d, 0x2d, 0x15, 0x16, 0x23, 0x5c, + 0x65, 0xb2, 0xc3, 0x83, 0xc4, 0x75, 0x25, 0xfa, 0x0a, 0x32, 0xcd, 0xc3, 0xbf, 0xa1, 0x86, 0x72, + 0xa9, 0xe7, 0xa4, 0x98, 0x79, 0x71, 0xdf, 0x14, 0x48, 0xfa, 0x11, 0x6c, 0xde, 0x14, 0xc0, 0x34, + 0xaf, 0x46, 0x74, 0xd6, 0x52, 0xb0, 0xd4, 0x12, 0x63, 0x4f, 0x91, 0x0a, 0x31, 0x22, 0xce, 0x11, + 0x78, 0x8d, 0xcd, 0x07, 0x11, 0xa4, 0x11, 0x9f, 0x02, 0x8a, 0x86, 0x1e, 0xb1, 0x45, 0x4b, 0x69, + 0x0d, 0x22, 0x05, 0x7d, 0x6c, 0xb3, 0x3b, 0x53, 0xa5, 0x1d, 0xb6, 0xe2, 0xfa, 0xe8, 0x73, 0xe0, + 0xe2, 0x68, 0x04, 0x8a, 0x9b, 0xa5, 0x27, 0xcb, 0x45, 0x6a, 0xe8, 0x2c, 0xe6, 0x21, 0xa9, 0x40, + 0x41, 0x46, 0x51, 0x93, 0xe5, 0x2f, 0x10, 0x25, 0x4e, 0xc6, 0x1e, 0xa7, 0x60, 0xa1, 0x7d, 0xaf, + 0xb1, 0x25, 0x21, 0x0a, 0xa2, 0xa0, 0x43, 0xc1, 0x32, 0x87, 0xe3, 0xef, 0xb3, 0x55, 0x2e, 0xd5, + 0x4e, 0xd9, 0x9a, 0xb7, 0x75, 0x12, 0x6a, 0xa3, 0x3b, 0xc3, 0x30, 0x86, 0x01, 0x98, 0x85, 0xd9, + 0x3f, 0x88, 0x12, 0x1c, 0x8f, 0x51, 0x83, 0x31, 0x3c, 0x88, 0xae, 0x86, 0x2c, 0x65, 0xfc, 0x06, + 0xd3, 0xe4, 0xd2, 0x9e, 0x67, 0xb9, 0xa3, 0x1e, 0x14, 0xe1, 0x25, 0x7b, 0xd4, 0x94, 0xf2, 0xb1, + 0x40, 0x17, 0x4b, 0xeb, 0xaa, 0x4f, 0xc2, 0xd2, 0x03, 0x72, 0x72, 0x21, 0xb7, 0x10, 0x0a, 0x22, + 0xa5, 0xc0, 0x38, 0xe3, 0x63, 0x11, 0x60, 0xd4, 0x91, 0x1c, 0xf0, 0xe4, 0x35, 0x14, 0xa3, 0xd4, + 0x29, 0x00, 0x62, 0x87, 0x91, 0x0b, 0x6e, 0x1c, 0x9f, 0x71, 0x9e, 0x17, 0x73, 0x35, 0x2a, 0x5b, + 0xfe, 0xb0, 0xce, 0x6e, 0xcd, 0x5a, 0x55, 0xd9, 0xc6, 0x14, 0xfb, 0x27, 0x91, 0x78, 0x0a, 0x4d, + 0x97, 0x40, 0xe0, 0x8a, 0x0d, 0xe7, 0x28, 0x33, 0xdf, 0x80, 0xb0, 0xba, 0x0c, 0xc1, 0x7a, 0x23, + 0xc4, 0xfd, 0xac, 0xa0, 0x27, 0x9d, 0x43, 0x42, 0x1a, 0x40, 0xc1, 0x9d, 0xc2, 0x09, 0x55, 0x78, + 0x5d, 0x92, 0x6b, 0x35, 0xc1, 0xe8, 0x9b, 0xf1, 0x59, 0xf0, 0xc6, 0x3c, 0x83, 0x4c, 0x8a, 0x48, + 0x1e, 0xb9, 0xa1, 0x48, 0x32, 0xad, 0x42, 0xd5, 0x01, 0xa1, 0x54, 0xd8, 0x98, 0xdc, 0x6d, 0x19, + 0xf0, 0x65, 0x0d, 0x7c, 0xd9, 0x82, 0x13, 0x08, 0x9e, 0x68, 0x16, 0x72, 0xbb, 0x26, 0x6e, 0x89, + 0x1d, 0x68, 0x10, 0xa6, 0x9e, 0x15, 0xc9, 0xfe, 0x8f, 0x11, 0x58, 0x99, 0x42, 0x97, 0xaf, 0x43, + 0x10, 0x90, 0x3a, 0xbe, 0x13, 0x28, 0x4e, 0x46, 0x59, 0x3a, 0x8e, 0xa9, 0x9a, 0x23, 0x8d, 0x2c, + 0x53, 0x46, 0x24, 0xc6, 0x44, 0x32, 0xd1, 0x52, 0xb4, 0x54, 0x56, 0x16, 0x0b, 0xcc, 0x34, 0xf2, + 0x84, 0x8e, 0x8c, 0xfb, 0x10, 0xa3, 0xd4, 0x40, 0xee, 0x47, 0x51, 0x10, 0x21, 0x5f, 0x8e, 0x3f, + 0xcc, 0x84, 0x5f, 0x26, 0xb2, 0xf1, 0xbb, 0x2d, 0xaa, 0xde, 0x63, 0x70, 0x43, 0x28, 0x3a, 0x0f, + 0x55, 0x88, 0x1e, 0xf3, 0x01, 0x18, 0xe4, 0xcc, 0xe8, 0x42, 0xb1, 0x80, 0x65, 0x63, 0xe0, 0x7f, + 0x61, 0x45, 0x5f, 0x20, 0x82, 0x64, 0x59, 0x51, 0xf4, 0xbe, 0x13, 0x38, 0xb3, 0x68, 0xfc, 0x92, + 0x38, 0xd2, 0x31, 0x0f, 0x3d, 0xd7, 0x86, 0x53, 0x89, 0x85, 0xb1, 0x7e, 0x1f, 0xcd, 0xe7, 0x5f, + 0xc0, 0x4f, 0x58, 0x27, 0xa1, 0x7d, 0x92, 0xaf, 0xe1, 0x28, 0x49, 0xb0, 0xce, 0x7b, 0x1d, 0x42, + 0x39, 0xe3, 0x70, 0xe7, 0x34, 0xf8, 0x5e, 0x90, 0x9e, 0xa6, 0x7d, 0x52, 0xfb, 0x18, 0x72, 0x05, + 0xfc, 0xa4, 0x03, 0x8a, 0xdd, 0x01, 0xd6, 0xd5, 0xa0, 0xf2, 0xf0, 0x42, 0xc6, 0x86, 0xf3, 0xc6, + 0x80, 0xae, 0xd8, 0x58, 0xca, 0xb6, 0x6f, 0x0e, 0x0e, 0xb4, 0x25, 0x37, 0x8e, 0xd3, 0x11, 0x96, + 0x16, 0xfb, 0x97, 0x67, 0x16, 0x14, 0xc5, 0x80, 0x7b, 0x33, 0xae, 0x1b, 0x9a, 0xc6, 0x6f, 0xd7, + 0xc4, 0x89, 0x08, 0x1d, 0x6c, 0xac, 0xdd, 0xa1, 0x1a, 0x19, 0x02, 0x75, 0x45, 0x50, 0xe5, 0x20, + 0x57, 0x9f, 0x06, 0xb9, 0x86, 0x6a, 0x45, 0x15, 0x7a, 0x09, 0xd4, 0x43, 0xef, 0xb7, 0xa2, 0x0c, + 0xf3, 0xf0, 0x59, 0x02, 0x17, 0x21, 0x9e, 0xd1, 0x67, 0xd7, 0x45, 0xd5, 0x9f, 0x1c, 0x81, 0x51, + 0x38, 0x05, 0xff, 0x51, 0x10, 0x8b, 0xf2, 0x06, 0x43, 0x85, 0x32, 0x79, 0x51, 0x8a, 0x90, 0xe8, + 0x72, 0xf4, 0x85, 0x2d, 0x29, 0x9d, 0x67, 0xdd, 0x2f, 0x0c, 0xa8, 0xd4, 0x32, 0x47, 0x7a, 0xf9, + 0x3d, 0x79, 0xce, 0x93, 0x49, 0xf6, 0xb1, 0xbe, 0x2d, 0x2b, 0xbe, 0x50, 0x8d, 0x48, 0x03, 0x1a, + 0xdd, 0x59, 0xe4, 0xdd, 0xe2, 0xd3, 0x8d, 0x8f, 0xd8, 0xf2, 0x84, 0xac, 0x85, 0x5d, 0xb3, 0x06, + 0x57, 0xf1, 0x95, 0x79, 0x25, 0x81, 0xb3, 0xe6, 0xd0, 0x27, 0xcf, 0x8b, 0xad, 0x0a, 0x66, 0xcb, + 0x6b, 0x85, 0xb3, 0x12, 0xf9, 0xee, 0xdc, 0x8f, 0xfe, 0xee, 0x36, 0xde, 0x46, 0x14, 0x4e, 0xdc, + 0x28, 0x4c, 0x6c, 0xe6, 0xe7, 0x9e, 0x2b, 0x0c, 0x17, 0xe4, 0x68, 0xca, 0xec, 0x2c, 0xf0, 0x89, + 0x7b, 0xdc, 0x4e, 0xf2, 0x8d, 0x9f, 0x05, 0x51, 0x0f, 0xf7, 0xfb, 0x4a, 0x4a, 0x36, 0x9e, 0xb2, + 0xfb, 0x57, 0x31, 0x41, 0xc7, 0x1e, 0x93, 0x25, 0x52, 0x68, 0x80, 0x65, 0x6a, 0x5d, 0x30, 0x7e, + 0x8d, 0x6d, 0xc2, 0x81, 0xc5, 0x22, 0xee, 0xe4, 0xcb, 0xa0, 0x3a, 0x9e, 0x72, 0x30, 0x29, 0x7e, + 0x95, 0x1a, 0xd6, 0xa6, 0xd4, 0x60, 0x0c, 0xd8, 0x0d, 0x81, 0x00, 0x2f, 0xb1, 0xe5, 0x03, 0xe6, + 0x2f, 0x83, 0xc4, 0x1d, 0x60, 0x68, 0xa2, 0x3d, 0x00, 0x37, 0x30, 0xd8, 0x78, 0x24, 0x9a, 0xcc, + 0xe2, 0xd5, 0x45, 0x1e, 0x09, 0xe4, 0xb9, 0xf5, 0xac, 0x60, 0xc7, 0x71, 0x9f, 0xca, 0x4d, 0x6a, + 0x25, 0x25, 0xd2, 0xfc, 0x7d, 0x4d, 0xdd, 0x55, 0x89, 0x3e, 0x70, 0xcf, 0x8d, 0x91, 0xf3, 0xc4, + 0x6e, 0xef, 0xb1, 0x8e, 0x5f, 0x78, 0x86, 0x3e, 0x37, 0x81, 0x06, 0x8f, 0xae, 0xec, 0xdc, 0x1f, + 0x8a, 0xa1, 0x73, 0xae, 0xee, 0xd4, 0xb0, 0xb7, 0x2b, 0x12, 0xf7, 0x03, 0x67, 0x3c, 0x4d, 0x5b, + 0x57, 0xa9, 0x80, 0xa6, 0xe3, 0xb4, 0x2f, 0x1b, 0x1e, 0x98, 0xc3, 0x22, 0xa7, 0x01, 0x93, 0x50, + 0xc9, 0x96, 0x26, 0x09, 0xaf, 0xc4, 0x65, 0xd6, 0xa2, 0xf1, 0x51, 0x76, 0xcf, 0x07, 0xc0, 0x4f, + 0x59, 0xf5, 0xc8, 0xb5, 0xcf, 0xb9, 0xf3, 0x3a, 0xac, 0xd2, 0x8e, 0xf1, 0x5b, 0xec, 0x9e, 0x58, + 0x72, 0xe8, 0xdb, 0x11, 0xc7, 0x0c, 0xf3, 0xb9, 0xeb, 0x79, 0x3d, 0xb4, 0x54, 0x96, 0xd0, 0xee, + 0xb2, 0xb5, 0x73, 0x18, 0x84, 0xb5, 0x15, 0x36, 0xc4, 0x22, 0x2b, 0x1d, 0x99, 0x48, 0x14, 0x4b, + 0xed, 0x82, 0x93, 0x65, 0x6d, 0xa4, 0x88, 0x52, 0xc0, 0x18, 0xd1, 0x68, 0xe5, 0xd7, 0x96, 0xc6, + 0xbf, 0xd5, 0xb2, 0xee, 0x1b, 0xc5, 0xdd, 0x8b, 0x82, 0xf0, 0x18, 0x80, 0x76, 0x37, 0xf0, 0xd3, + 0xf8, 0x0a, 0x9f, 0xd9, 0xa2, 0x8c, 0x28, 0xfb, 0x57, 0xcc, 0x88, 0x5c, 0xe6, 0x8e, 0x75, 0xd6, + 0xec, 0xe3, 0x5a, 0xda, 0xb2, 0x2e, 0xa9, 0x01, 0x0a, 0x69, 0x50, 0x14, 0xd7, 0x12, 0xa6, 0xca, + 0x51, 0x33, 0x89, 0x6d, 0xf3, 0xaa, 0x6b, 0x8c, 0x39, 0x76, 0x67, 0xd0, 0x63, 0xf3, 0x41, 0x22, + 0xca, 0x33, 0x48, 0xc7, 0xcb, 0x7d, 0xe8, 0xcf, 0xa1, 0x9c, 0x12, 0x27, 0x59, 0xc8, 0x05, 0x33, + 0xde, 0x4c, 0x04, 0xfc, 0x73, 0x6e, 0x0d, 0x53, 0xfe, 0x05, 0xb4, 0xd4, 0x47, 0x18, 0x77, 0x57, + 0x9d, 0x67, 0xd1, 0x23, 0xda, 0x19, 0x41, 0x80, 0x52, 0x16, 0xab, 0x4a, 0x10, 0x0a, 0x6a, 0x75, + 0xe0, 0x11, 0x71, 0x2b, 0x06, 0xa4, 0x21, 0x94, 0x35, 0x5e, 0xb1, 0x6b, 0xc5, 0x22, 0x0b, 0x61, + 0xfb, 0x14, 0x4d, 0x9f, 0xcc, 0x84, 0x76, 0x30, 0x0e, 0x47, 0x92, 0x09, 0x4c, 0x55, 0xea, 0x10, + 0xa9, 0xe5, 0x5f, 0xf1, 0x42, 0x3b, 0xe7, 0x78, 0x1a, 0xa4, 0x11, 0x06, 0x8a, 0x9f, 0xe0, 0x51, + 0x42, 0x28, 0x08, 0xaa, 0x72, 0x46, 0xe9, 0x20, 0x53, 0x9c, 0xd1, 0x87, 0xb3, 0xf2, 0x51, 0xdd, + 0x24, 0x44, 0x19, 0xa8, 0x61, 0x58, 0x86, 0x72, 0x8b, 0x18, 0x02, 0x25, 0x1d, 0x9e, 0x25, 0x32, + 0x93, 0x00, 0x27, 0x55, 0x29, 0xcc, 0x4f, 0xa7, 0xa3, 0x96, 0xd2, 0x4e, 0xc4, 0xdf, 0x58, 0x91, + 0xe8, 0xb1, 0x65, 0xfd, 0x6c, 0xec, 0xb0, 0x6f, 0x4a, 0x27, 0x17, 0x88, 0x84, 0xb7, 0x1c, 0xf8, + 0x73, 0x97, 0xd8, 0x97, 0x51, 0xa4, 0x84, 0x16, 0xa2, 0x14, 0x7d, 0x4f, 0xa4, 0xad, 0xd2, 0xf5, + 0x75, 0x0f, 0x91, 0xdc, 0x2b, 0x5c, 0x54, 0x53, 0x26, 0x80, 0xba, 0xf2, 0x7e, 0x25, 0x71, 0x45, + 0x99, 0xb8, 0x62, 0x7c, 0x20, 0x4a, 0x86, 0xd2, 0xa2, 0x67, 0xa8, 0x27, 0xf7, 0x87, 0x7c, 0x6a, + 0x8f, 0x03, 0xd6, 0xb9, 0x82, 0xbc, 0x6a, 0x97, 0x2c, 0x2e, 0x5d, 0x07, 0x23, 0xb5, 0x01, 0x8c, + 0x0e, 0xd5, 0xbe, 0xbb, 0x96, 0xef, 0x73, 0xe7, 0xcb, 0x20, 0x72, 0x9e, 0xbb, 0x71, 0x22, 0x8b, + 0x28, 0xac, 0x30, 0xf1, 0xbe, 0x08, 0x2f, 0x99, 0xcc, 0x89, 0x1b, 0x5d, 0x32, 0xc8, 0x1b, 0xa0, + 0xce, 0x93, 0x46, 0x0a, 0xf5, 0x7a, 0x89, 0x55, 0x91, 0x48, 0xac, 0xda, 0x65, 0x8b, 0x34, 0x90, + 0x15, 0xeb, 0xab, 0x4f, 0xf4, 0xee, 0x41, 0xcf, 0xcc, 0xd7, 0x9c, 0xc2, 0xcc, 0xf6, 0x4d, 0x1c, + 0xda, 0x79, 0xf9, 0x72, 0x7f, 0xcf, 0xfc, 0xf2, 0xd5, 0xf1, 0x9e, 0xb9, 0x77, 0x78, 0xb2, 0xb3, + 0xfb, 0x7c, 0x9f, 0x1e, 0xb0, 0x6c, 0x43, 0x1e, 0x12, 0xaf, 0x4d, 0x91, 0xf0, 0xa6, 0x4f, 0x20, + 0x75, 0x70, 0xc5, 0x11, 0x1e, 0x48, 0x61, 0xe8, 0x0e, 0xad, 0x4e, 0xb5, 0xc0, 0x5a, 0xb7, 0xcc, + 0xcc, 0x78, 0xad, 0xec, 0x79, 0x1a, 0x94, 0x37, 0xc9, 0x5f, 0x43, 0x7c, 0xc8, 0x16, 0xfb, 0xea, + 0x41, 0x5e, 0x53, 0xde, 0xee, 0x5e, 0x25, 0x17, 0xb8, 0xc9, 0xdd, 0x2a, 0xb6, 0xa2, 0x8c, 0x9e, + 0xbe, 0x46, 0x5f, 0x31, 0x7e, 0x45, 0x61, 0x3c, 0x2e, 0xda, 0x73, 0xa3, 0x64, 0x7c, 0xb2, 0xf7, + 0xaa, 0x87, 0x37, 0x81, 0x74, 0x33, 0xec, 0x04, 0x85, 0x06, 0x0a, 0x63, 0x14, 0xb2, 0x87, 0x99, + 0x42, 0xf7, 0xf7, 0xe9, 0x53, 0xd9, 0x77, 0x1f, 0x14, 0x77, 0x25, 0x06, 0x2f, 0xc0, 0x3d, 0xdc, + 0xd0, 0xe3, 0x5f, 0x83, 0x11, 0x3a, 0xce, 0x67, 0x45, 0x46, 0x74, 0x17, 0xf0, 0xbc, 0x90, 0xd2, + 0xf6, 0xdc, 0xc1, 0x60, 0xe2, 0x65, 0x52, 0x4d, 0xf5, 0xee, 0x78, 0x87, 0x0a, 0xed, 0x8a, 0x03, + 0x04, 0xb2, 0xd0, 0xde, 0x56, 0xf1, 0x59, 0xc9, 0x29, 0xb3, 0xe5, 0x54, 0xc9, 0xf1, 0x99, 0xb8, + 0x23, 0x87, 0x5c, 0x1d, 0x78, 0xaa, 0x56, 0x01, 0x8c, 0xd6, 0x6d, 0xf1, 0x48, 0xf5, 0x72, 0xf9, + 0x56, 0x03, 0xd2, 0xe7, 0xf7, 0x61, 0xae, 0x74, 0x21, 0xb1, 0x21, 0xde, 0x1a, 0x81, 0x16, 0x5e, + 0x06, 0x2f, 0xf8, 0xc8, 0x46, 0x55, 0x38, 0xc6, 0xb7, 0x55, 0x78, 0xa0, 0x6c, 0xc2, 0x2c, 0x27, + 0xdf, 0x7d, 0xfe, 0x39, 0x1f, 0x8b, 0x06, 0x02, 0x4e, 0x88, 0x8a, 0xc9, 0x9b, 0x08, 0xe3, 0x17, + 0x27, 0x9c, 0x45, 0x79, 0x04, 0xd6, 0xe8, 0x81, 0x07, 0x2d, 0xc4, 0x68, 0x64, 0xf9, 0x54, 0x9e, + 0xdb, 0xf4, 0x5a, 0x89, 0x1e, 0xe5, 0xca, 0xa7, 0xaa, 0xbe, 0x11, 0xd7, 0xd6, 0x5f, 0x08, 0xb0, + 0x53, 0xae, 0x40, 0xd7, 0x54, 0x38, 0x3e, 0xd1, 0x8f, 0xae, 0xe4, 0xab, 0x44, 0xb1, 0x32, 0xbd, + 0xaa, 0xf4, 0x4a, 0x42, 0xac, 0xba, 0xc7, 0xee, 0xe4, 0x52, 0x7e, 0xc9, 0xfb, 0x3b, 0x47, 0x87, + 0xea, 0xee, 0xfb, 0x0c, 0x6f, 0x96, 0x1c, 0xf0, 0x93, 0x75, 0xd1, 0xc2, 0xe0, 0x8d, 0x22, 0xc8, + 0x0d, 0xfa, 0xc7, 0x3b, 0xf1, 0x19, 0xea, 0xcb, 0xf4, 0x9a, 0x5d, 0x47, 0x14, 0x0a, 0xad, 0x39, + 0x23, 0x10, 0x0a, 0x79, 0x96, 0x7a, 0x03, 0x28, 0x10, 0xf6, 0xc6, 0xa0, 0x2b, 0xd7, 0x2e, 0xb3, + 0x05, 0xe0, 0x4e, 0x82, 0xc0, 0x2b, 0xf1, 0x7c, 0x8a, 0x6f, 0x43, 0xb1, 0xb9, 0xa1, 0xd6, 0x15, + 0xd5, 0x25, 0xc8, 0x63, 0x19, 0xab, 0x1b, 0xdd, 0x19, 0x22, 0x1a, 0x9f, 0x42, 0xea, 0x2a, 0x68, + 0xe4, 0x85, 0x15, 0x41, 0x22, 0x14, 0x2d, 0xba, 0xc0, 0x34, 0x68, 0x61, 0xe9, 0xc5, 0x53, 0xd6, + 0x96, 0xd7, 0xd4, 0x6b, 0xb9, 0x9b, 0xb3, 0x17, 0xee, 0x63, 0xaf, 0x5e, 0x95, 0x1b, 0x66, 0xde, + 0x2e, 0x63, 0x9d, 0xa0, 0x8b, 0x26, 0x97, 0x7b, 0x1e, 0xe1, 0x0b, 0xbd, 0x28, 0x14, 0xb5, 0xd0, + 0x5d, 0xb6, 0x25, 0xda, 0xee, 0xe9, 0xd7, 0xbc, 0xa2, 0x30, 0x3a, 0x10, 0xaf, 0x30, 0xa6, 0x25, + 0xd1, 0x3f, 0x60, 0x2d, 0x18, 0x88, 0x5c, 0xae, 0x7a, 0x97, 0x5b, 0xdd, 0x2b, 0x64, 0x86, 0x8a, + 0x9c, 0x7a, 0xde, 0xfd, 0xcb, 0x24, 0xb2, 0xec, 0xe4, 0x00, 0x2f, 0x5a, 0x66, 0xab, 0x7a, 0xe6, + 0xb5, 0x21, 0x24, 0xeb, 0x55, 0x79, 0x05, 0x80, 0xc5, 0x44, 0x56, 0x8a, 0x6f, 0x37, 0x3f, 0xfd, + 0xe4, 0x93, 0x8f, 0x3f, 0x31, 0xfe, 0xbd, 0x2e, 0xd0, 0xa8, 0xc0, 0xbe, 0x18, 0xa9, 0x93, 0x3b, + 0x1c, 0xe1, 0x4d, 0xbf, 0x98, 0x94, 0xb8, 0xff, 0x6e, 0xb7, 0x62, 0x71, 0x77, 0xbf, 0x30, 0xb8, + 0xbd, 0x75, 0x6e, 0x16, 0x1e, 0xcd, 0x13, 0x8c, 0x7f, 0x0e, 0xfd, 0xb4, 0xf1, 0xf3, 0x1a, 0x5b, + 0x2e, 0x52, 0x42, 0xf1, 0x5c, 0x45, 0xab, 0x7d, 0x43, 0x7f, 0xc8, 0x8c, 0xc9, 0xc9, 0x67, 0xe2, + 0xdd, 0xec, 0x29, 0x28, 0xe3, 0x30, 0x3e, 0x84, 0x86, 0xde, 0x73, 0x1d, 0xad, 0x56, 0x49, 0x87, + 0xc8, 0x92, 0xd3, 0xd5, 0xf5, 0xf7, 0xd9, 0xa3, 0x4a, 0x7e, 0x90, 0xeb, 0xa1, 0xe2, 0x3f, 0xe6, + 0xa3, 0xe0, 0x82, 0xc3, 0x9c, 0xd6, 0x80, 0x1e, 0xe0, 0xe1, 0x4c, 0x6a, 0xf1, 0xef, 0x34, 0xc8, + 0x69, 0xe7, 0x8c, 0xe7, 0xe2, 0x6e, 0x6c, 0xc7, 0x71, 0x4e, 0x48, 0xef, 0x5f, 0xcb, 0x64, 0xa0, + 0xf7, 0x14, 0xaa, 0x5d, 0xf0, 0x45, 0xf9, 0x42, 0xf5, 0x1f, 0xea, 0xe2, 0x25, 0x6d, 0xc6, 0xae, + 0xda, 0x44, 0xb7, 0xd8, 0x46, 0x2a, 0x80, 0x23, 0xb3, 0xb8, 0x0c, 0xe4, 0x06, 0x78, 0xed, 0x77, + 0x0a, 0x06, 0x6c, 0x90, 0x01, 0xef, 0x77, 0x67, 0x32, 0xee, 0xee, 0x67, 0x43, 0xdb, 0x9b, 0xe7, + 0x66, 0xf6, 0x50, 0x30, 0xdd, 0xdf, 0xd6, 0x18, 0xcb, 0xa9, 0x20, 0x45, 0xcf, 0xa6, 0x03, 0xb3, + 0x3d, 0x60, 0xf7, 0x8a, 0x53, 0x15, 0x46, 0x7b, 0x8f, 0x7d, 0x73, 0x06, 0x15, 0x5d, 0xb7, 0x93, + 0x29, 0x76, 0xb9, 0x98, 0xe1, 0x68, 0xb9, 0x47, 0xec, 0xc1, 0x0c, 0x62, 0x65, 0x89, 0x6c, 0x42, + 0x6b, 0x18, 0x7b, 0xf2, 0xda, 0xdc, 0x71, 0x44, 0x15, 0x2c, 0x26, 0x28, 0x10, 0x01, 0xc2, 0x87, + 0x05, 0xe5, 0x67, 0x26, 0x29, 0x29, 0x0e, 0xa3, 0xf9, 0xd7, 0xe5, 0x7d, 0xf9, 0x24, 0x97, 0x29, + 0xfb, 0x09, 0x16, 0x1f, 0xb2, 0xd5, 0x21, 0xfa, 0x47, 0x12, 0x48, 0x1b, 0x48, 0xac, 0x6b, 0x77, + 0x2b, 0x24, 0x31, 0xfe, 0xa3, 0x21, 0x70, 0xab, 0x34, 0x97, 0x99, 0x79, 0xf6, 0x3e, 0x5f, 0xd7, + 0xd6, 0x0f, 0xba, 0x57, 0xec, 0x41, 0x16, 0x07, 0xe7, 0xdd, 0xd6, 0x49, 0xb1, 0xf0, 0xab, 0x60, + 0xeb, 0x7f, 0xaa, 0xb3, 0x96, 0x9c, 0x07, 0x0c, 0x9d, 0x41, 0x01, 0x56, 0xbe, 0xc7, 0x6e, 0x65, + 0xe3, 0xd2, 0x1e, 0x07, 0xc5, 0x70, 0xab, 0xe9, 0xf7, 0xd9, 0xed, 0x32, 0x45, 0x39, 0x22, 0x0d, + 0x76, 0xa7, 0x4c, 0x52, 0x30, 0xaa, 0x88, 0x43, 0xe5, 0x28, 0x45, 0x36, 0x82, 0x01, 0x8c, 0x60, + 0xe5, 0xf9, 0x2c, 0x88, 0xa4, 0xf9, 0xe7, 0xf4, 0x6f, 0xb1, 0x77, 0xdf, 0x4a, 0xfc, 0x19, 0x8f, + 0x02, 0xad, 0xf9, 0x95, 0x48, 0x4f, 0xbc, 0x20, 0xd1, 0xe6, 0xc1, 0xc2, 0xef, 0x97, 0x49, 0xc5, + 0x8e, 0x50, 0x24, 0x24, 0x96, 0xeb, 0xc7, 0xaf, 0xfd, 0x08, 0xd1, 0x00, 0x6f, 0xf4, 0x50, 0xe8, + 0x96, 0xf1, 0x0c, 0xda, 0x64, 0x4a, 0x74, 0x31, 0x4f, 0xe4, 0x9b, 0x20, 0x98, 0xa0, 0x2e, 0xbd, + 0xc2, 0xba, 0xb3, 0x1d, 0xf1, 0x1f, 0xeb, 0xa2, 0xdd, 0x9f, 0xc5, 0x28, 0x73, 0x97, 0x93, 0x82, + 0xe9, 0xc5, 0xe7, 0x01, 0xef, 0x75, 0xdf, 0xb6, 0xa8, 0xbb, 0x4f, 0xb3, 0xe8, 0x01, 0x1b, 0xe7, + 0xa6, 0xfa, 0x5d, 0xf0, 0x81, 0x7f, 0xae, 0xb1, 0xc5, 0x8c, 0x06, 0x9a, 0xbc, 0x99, 0x54, 0x0a, + 0xa4, 0xb3, 0x99, 0x29, 0x8c, 0x14, 0xe3, 0xe0, 0x0d, 0x1d, 0x76, 0x77, 0x9a, 0xae, 0xec, 0x0f, + 0xef, 0xb2, 0xfb, 0x33, 0x88, 0xc4, 0xb4, 0xd0, 0xf8, 0xa1, 0x03, 0x2e, 0x41, 0xa6, 0x2b, 0x93, + 0x49, 0x8b, 0x48, 0xf0, 0xa0, 0x59, 0x6d, 0xee, 0xf1, 0xff, 0x34, 0x00, 0xb6, 0xb0, 0x58, 0x8f, + 0x39, 0x68, 0x04, 0x72, 0x3c, 0xc0, 0xd6, 0xbe, 0xa8, 0xd9, 0xe8, 0xab, 0xa4, 0x17, 0xe2, 0x33, + 0x08, 0xed, 0xa7, 0x77, 0x21, 0x75, 0xb6, 0xd5, 0x5c, 0xf9, 0x06, 0x59, 0xfb, 0xd9, 0xdd, 0xe2, + 0x52, 0x31, 0x2a, 0x2b, 0x36, 0xed, 0x6f, 0x26, 0xe6, 0x26, 0x3e, 0x11, 0xd2, 0xfe, 0xa8, 0xa3, + 0xdf, 0x61, 0xd7, 0x27, 0xe6, 0x8a, 0x5f, 0xdd, 0x68, 0x7f, 0xdc, 0x81, 0x40, 0xba, 0xa9, 0xe6, + 0x67, 0x7c, 0x42, 0xa3, 0xfd, 0x49, 0xa7, 0xc8, 0x7d, 0xe2, 0xcb, 0x12, 0xed, 0x4f, 0x3b, 0x50, + 0xc4, 0xe9, 0x6a, 0x2e, 0xff, 0x9c, 0x44, 0xfb, 0xb3, 0x0e, 0xa0, 0xc5, 0x56, 0x76, 0xd2, 0xc9, + 0x8f, 0x2a, 0xb4, 0x1f, 0x77, 0x20, 0xf0, 0x6e, 0x67, 0x87, 0xa1, 0x32, 0x04, 0x8e, 0xe4, 0x43, + 0x89, 0x08, 0x30, 0x41, 0xc4, 0xda, 0x9f, 0x77, 0x20, 0x37, 0x5f, 0x53, 0x34, 0xf8, 0xa5, 0x85, + 0x98, 0x38, 0xf4, 0x07, 0x81, 0xf6, 0x17, 0x1d, 0xe8, 0x2f, 0x56, 0xd4, 0x24, 0x5d, 0xef, 0x6b, + 0x7f, 0xd9, 0x01, 0xeb, 0xdd, 0x2b, 0x2a, 0xd0, 0x1a, 0x9b, 0x53, 0x17, 0xe9, 0xda, 0x4f, 0x3a, + 0x50, 0x4b, 0xdd, 0xc8, 0x44, 0x9e, 0xfa, 0xe2, 0x43, 0xfb, 0xab, 0xce, 0x2c, 0x6d, 0xd2, 0xe7, + 0x3d, 0xda, 0x5f, 0x4f, 0x68, 0x6b, 0xc6, 0x27, 0x3f, 0xda, 0x4f, 0x3b, 0x8f, 0xbf, 0xc7, 0xb6, + 0xa4, 0xc1, 0x8f, 0xf0, 0x4b, 0xbf, 0x57, 0x54, 0xfa, 0x62, 0x3c, 0xc7, 0xd2, 0x14, 0x85, 0xe1, + 0x82, 0xc2, 0xb5, 0xff, 0x6a, 0x4d, 0xcf, 0x17, 0xb6, 0xd0, 0xfe, 0xbb, 0xf5, 0xf8, 0x3f, 0x1b, + 0xac, 0x5d, 0xf5, 0x6d, 0x8d, 0xac, 0x42, 0xde, 0xf2, 0xe5, 0x8d, 0x4a, 0x8f, 0x95, 0x74, 0xc7, + 0xdc, 0x72, 0xc6, 0x2a, 0x5c, 0x2a, 0xa9, 0x76, 0xd3, 0x78, 0x9c, 0x15, 0x34, 0x55, 0x44, 0x22, + 0x2e, 0x0e, 0xb8, 0xcf, 0xa1, 0x72, 0xd5, 0xb8, 0xfe, 0x84, 0x75, 0xdf, 0x4a, 0x7d, 0x88, 0x6f, + 0x1d, 0x7d, 0xcb, 0x13, 0x36, 0x1d, 0xe8, 0xbf, 0xc0, 0x3e, 0xbe, 0x52, 0x58, 0x2a, 0xcf, 0xc1, + 0xbe, 0xea, 0xa3, 0x21, 0xc8, 0xf2, 0xaf, 0x3c, 0x47, 0x1b, 0xfe, 0x7f, 0x16, 0xbe, 0xe4, 0x6f, + 0xb4, 0x33, 0x59, 0x76, 0x55, 0x2d, 0xec, 0x1d, 0xf7, 0x5e, 0xb8, 0xf1, 0xc8, 0x4a, 0xec, 0x33, + 0xcd, 0x7d, 0x0b, 0xad, 0x38, 0xd1, 0x09, 0xde, 0x9e, 0x6a, 0xdf, 0x87, 0x32, 0xfc, 0x5b, 0x6f, + 0xa5, 0x15, 0x17, 0x3e, 0x10, 0x96, 0xe7, 0x8f, 0x4f, 0xd9, 0xda, 0xd4, 0x15, 0x07, 0x78, 0xee, + 0x55, 0x97, 0x1c, 0x60, 0xdb, 0x3b, 0xec, 0x46, 0x89, 0x60, 0xff, 0x65, 0x3e, 0x5f, 0xdb, 0x6d, + 0x7e, 0x56, 0xfb, 0x51, 0xed, 0x1b, 0xff, 0x17, 0x00, 0x00, 0xff, 0xff, 0xde, 0x29, 0x50, 0xc3, + 0xa9, 0x2a, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_client.pb.go b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_client.pb.go new file mode 100644 index 00000000..8677b820 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_client.pb.go @@ -0,0 +1,18413 @@ +// Code generated by protoc-gen-go. +// source: dota_gcmessages_client.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 protobuf is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type EMatchGroupServerStatus int32 + +const ( + EMatchGroupServerStatus_k_EMatchGroupServerStatus_OK EMatchGroupServerStatus = 0 + EMatchGroupServerStatus_k_EMatchGroupServerStatus_LimitedAvailability EMatchGroupServerStatus = 1 + EMatchGroupServerStatus_k_EMatchGroupServerStatus_Offline EMatchGroupServerStatus = 2 +) + +var EMatchGroupServerStatus_name = map[int32]string{ + 0: "k_EMatchGroupServerStatus_OK", + 1: "k_EMatchGroupServerStatus_LimitedAvailability", + 2: "k_EMatchGroupServerStatus_Offline", +} +var EMatchGroupServerStatus_value = map[string]int32{ + "k_EMatchGroupServerStatus_OK": 0, + "k_EMatchGroupServerStatus_LimitedAvailability": 1, + "k_EMatchGroupServerStatus_Offline": 2, +} + +func (x EMatchGroupServerStatus) Enum() *EMatchGroupServerStatus { + p := new(EMatchGroupServerStatus) + *p = x + return p +} +func (x EMatchGroupServerStatus) String() string { + return proto.EnumName(EMatchGroupServerStatus_name, int32(x)) +} +func (x *EMatchGroupServerStatus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EMatchGroupServerStatus_value, data, "EMatchGroupServerStatus") + if err != nil { + return err + } + *x = EMatchGroupServerStatus(value) + return nil +} +func (EMatchGroupServerStatus) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{0} } + +type DOTA_WatchReplayType int32 + +const ( + DOTA_WatchReplayType_DOTA_WATCH_REPLAY_NORMAL DOTA_WatchReplayType = 0 + DOTA_WatchReplayType_DOTA_WATCH_REPLAY_HIGHLIGHTS DOTA_WatchReplayType = 1 +) + +var DOTA_WatchReplayType_name = map[int32]string{ + 0: "DOTA_WATCH_REPLAY_NORMAL", + 1: "DOTA_WATCH_REPLAY_HIGHLIGHTS", +} +var DOTA_WatchReplayType_value = map[string]int32{ + "DOTA_WATCH_REPLAY_NORMAL": 0, + "DOTA_WATCH_REPLAY_HIGHLIGHTS": 1, +} + +func (x DOTA_WatchReplayType) Enum() *DOTA_WatchReplayType { + p := new(DOTA_WatchReplayType) + *p = x + return p +} +func (x DOTA_WatchReplayType) String() string { + return proto.EnumName(DOTA_WatchReplayType_name, int32(x)) +} +func (x *DOTA_WatchReplayType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_WatchReplayType_value, data, "DOTA_WatchReplayType") + if err != nil { + return err + } + *x = DOTA_WatchReplayType(value) + return nil +} +func (DOTA_WatchReplayType) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{1} } + +type EItemEditorReservationResult int32 + +const ( + EItemEditorReservationResult_k_EItemEditorReservationResult_OK EItemEditorReservationResult = 1 + EItemEditorReservationResult_k_EItemEditorReservationResult_AlreadyExists EItemEditorReservationResult = 2 + EItemEditorReservationResult_k_EItemEditorReservationResult_Reserved EItemEditorReservationResult = 3 + EItemEditorReservationResult_k_EItemEditorReservationResult_TimedOut EItemEditorReservationResult = 4 +) + +var EItemEditorReservationResult_name = map[int32]string{ + 1: "k_EItemEditorReservationResult_OK", + 2: "k_EItemEditorReservationResult_AlreadyExists", + 3: "k_EItemEditorReservationResult_Reserved", + 4: "k_EItemEditorReservationResult_TimedOut", +} +var EItemEditorReservationResult_value = map[string]int32{ + "k_EItemEditorReservationResult_OK": 1, + "k_EItemEditorReservationResult_AlreadyExists": 2, + "k_EItemEditorReservationResult_Reserved": 3, + "k_EItemEditorReservationResult_TimedOut": 4, +} + +func (x EItemEditorReservationResult) Enum() *EItemEditorReservationResult { + p := new(EItemEditorReservationResult) + *p = x + return p +} +func (x EItemEditorReservationResult) String() string { + return proto.EnumName(EItemEditorReservationResult_name, int32(x)) +} +func (x *EItemEditorReservationResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EItemEditorReservationResult_value, data, "EItemEditorReservationResult") + if err != nil { + return err + } + *x = EItemEditorReservationResult(value) + return nil +} +func (EItemEditorReservationResult) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{2} } + +type EProfileCardSlotType int32 + +const ( + EProfileCardSlotType_k_EProfileCardSlotType_Empty EProfileCardSlotType = 0 + EProfileCardSlotType_k_EProfileCardSlotType_Stat EProfileCardSlotType = 1 + EProfileCardSlotType_k_EProfileCardSlotType_Trophy EProfileCardSlotType = 2 + EProfileCardSlotType_k_EProfileCardSlotType_Item EProfileCardSlotType = 3 + EProfileCardSlotType_k_EProfileCardSlotType_Hero EProfileCardSlotType = 4 + EProfileCardSlotType_k_EProfileCardSlotType_Emoticon EProfileCardSlotType = 5 +) + +var EProfileCardSlotType_name = map[int32]string{ + 0: "k_EProfileCardSlotType_Empty", + 1: "k_EProfileCardSlotType_Stat", + 2: "k_EProfileCardSlotType_Trophy", + 3: "k_EProfileCardSlotType_Item", + 4: "k_EProfileCardSlotType_Hero", + 5: "k_EProfileCardSlotType_Emoticon", +} +var EProfileCardSlotType_value = map[string]int32{ + "k_EProfileCardSlotType_Empty": 0, + "k_EProfileCardSlotType_Stat": 1, + "k_EProfileCardSlotType_Trophy": 2, + "k_EProfileCardSlotType_Item": 3, + "k_EProfileCardSlotType_Hero": 4, + "k_EProfileCardSlotType_Emoticon": 5, +} + +func (x EProfileCardSlotType) Enum() *EProfileCardSlotType { + p := new(EProfileCardSlotType) + *p = x + return p +} +func (x EProfileCardSlotType) String() string { + return proto.EnumName(EProfileCardSlotType_name, int32(x)) +} +func (x *EProfileCardSlotType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EProfileCardSlotType_value, data, "EProfileCardSlotType") + if err != nil { + return err + } + *x = EProfileCardSlotType(value) + return nil +} +func (EProfileCardSlotType) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{3} } + +type EFeaturedHeroTextField int32 + +const ( + EFeaturedHeroTextField_k_EFeaturedHeroTextField_NewHero EFeaturedHeroTextField = 0 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_NewItem EFeaturedHeroTextField = 1 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_ItemSetDescription EFeaturedHeroTextField = 2 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_ItemDescription EFeaturedHeroTextField = 3 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_Hype EFeaturedHeroTextField = 4 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_HeroWinLoss EFeaturedHeroTextField = 5 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_FrequentlyPlayedHero EFeaturedHeroTextField = 6 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_FeaturedItem EFeaturedHeroTextField = 7 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_PopularItem EFeaturedHeroTextField = 8 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_SaleItem EFeaturedHeroTextField = 9 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_SaleDiscount EFeaturedHeroTextField = 10 + EFeaturedHeroTextField_k_EFeaturedHeroTextField_Container EFeaturedHeroTextField = 11 +) + +var EFeaturedHeroTextField_name = map[int32]string{ + 0: "k_EFeaturedHeroTextField_NewHero", + 1: "k_EFeaturedHeroTextField_NewItem", + 2: "k_EFeaturedHeroTextField_ItemSetDescription", + 3: "k_EFeaturedHeroTextField_ItemDescription", + 4: "k_EFeaturedHeroTextField_Hype", + 5: "k_EFeaturedHeroTextField_HeroWinLoss", + 6: "k_EFeaturedHeroTextField_FrequentlyPlayedHero", + 7: "k_EFeaturedHeroTextField_FeaturedItem", + 8: "k_EFeaturedHeroTextField_PopularItem", + 9: "k_EFeaturedHeroTextField_SaleItem", + 10: "k_EFeaturedHeroTextField_SaleDiscount", + 11: "k_EFeaturedHeroTextField_Container", +} +var EFeaturedHeroTextField_value = map[string]int32{ + "k_EFeaturedHeroTextField_NewHero": 0, + "k_EFeaturedHeroTextField_NewItem": 1, + "k_EFeaturedHeroTextField_ItemSetDescription": 2, + "k_EFeaturedHeroTextField_ItemDescription": 3, + "k_EFeaturedHeroTextField_Hype": 4, + "k_EFeaturedHeroTextField_HeroWinLoss": 5, + "k_EFeaturedHeroTextField_FrequentlyPlayedHero": 6, + "k_EFeaturedHeroTextField_FeaturedItem": 7, + "k_EFeaturedHeroTextField_PopularItem": 8, + "k_EFeaturedHeroTextField_SaleItem": 9, + "k_EFeaturedHeroTextField_SaleDiscount": 10, + "k_EFeaturedHeroTextField_Container": 11, +} + +func (x EFeaturedHeroTextField) Enum() *EFeaturedHeroTextField { + p := new(EFeaturedHeroTextField) + *p = x + return p +} +func (x EFeaturedHeroTextField) String() string { + return proto.EnumName(EFeaturedHeroTextField_name, int32(x)) +} +func (x *EFeaturedHeroTextField) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EFeaturedHeroTextField_value, data, "EFeaturedHeroTextField") + if err != nil { + return err + } + *x = EFeaturedHeroTextField(value) + return nil +} +func (EFeaturedHeroTextField) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{4} } + +type EFeaturedHeroDataType int32 + +const ( + EFeaturedHeroDataType_k_EFeaturedHeroDataType_HeroID EFeaturedHeroDataType = 0 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_ItemDef EFeaturedHeroDataType = 1 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_HypeString EFeaturedHeroDataType = 2 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_StartTimestamp EFeaturedHeroDataType = 3 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_ExpireTimestamp EFeaturedHeroDataType = 4 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_HeroWins EFeaturedHeroDataType = 5 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_HeroLosses EFeaturedHeroDataType = 6 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_SaleDiscount EFeaturedHeroDataType = 7 + EFeaturedHeroDataType_k_EFeaturedHeroDataType_ContainerItemDef EFeaturedHeroDataType = 8 +) + +var EFeaturedHeroDataType_name = map[int32]string{ + 0: "k_EFeaturedHeroDataType_HeroID", + 1: "k_EFeaturedHeroDataType_ItemDef", + 2: "k_EFeaturedHeroDataType_HypeString", + 3: "k_EFeaturedHeroDataType_StartTimestamp", + 4: "k_EFeaturedHeroDataType_ExpireTimestamp", + 5: "k_EFeaturedHeroDataType_HeroWins", + 6: "k_EFeaturedHeroDataType_HeroLosses", + 7: "k_EFeaturedHeroDataType_SaleDiscount", + 8: "k_EFeaturedHeroDataType_ContainerItemDef", +} +var EFeaturedHeroDataType_value = map[string]int32{ + "k_EFeaturedHeroDataType_HeroID": 0, + "k_EFeaturedHeroDataType_ItemDef": 1, + "k_EFeaturedHeroDataType_HypeString": 2, + "k_EFeaturedHeroDataType_StartTimestamp": 3, + "k_EFeaturedHeroDataType_ExpireTimestamp": 4, + "k_EFeaturedHeroDataType_HeroWins": 5, + "k_EFeaturedHeroDataType_HeroLosses": 6, + "k_EFeaturedHeroDataType_SaleDiscount": 7, + "k_EFeaturedHeroDataType_ContainerItemDef": 8, +} + +func (x EFeaturedHeroDataType) Enum() *EFeaturedHeroDataType { + p := new(EFeaturedHeroDataType) + *p = x + return p +} +func (x EFeaturedHeroDataType) String() string { + return proto.EnumName(EFeaturedHeroDataType_name, int32(x)) +} +func (x *EFeaturedHeroDataType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EFeaturedHeroDataType_value, data, "EFeaturedHeroDataType") + if err != nil { + return err + } + *x = EFeaturedHeroDataType(value) + return nil +} +func (EFeaturedHeroDataType) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{5} } + +type EDOTAGroupMergeResult int32 + +const ( + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_OK EDOTAGroupMergeResult = 0 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_FAILED_GENERIC EDOTAGroupMergeResult = 1 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_NOT_LEADER EDOTAGroupMergeResult = 2 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_TOO_MANY_PLAYERS EDOTAGroupMergeResult = 3 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_TOO_MANY_COACHES EDOTAGroupMergeResult = 4 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_ENGINE_MISMATCH EDOTAGroupMergeResult = 5 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_NO_SUCH_GROUP EDOTAGroupMergeResult = 6 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_OTHER_GROUP_NOT_OPEN EDOTAGroupMergeResult = 7 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_ALREADY_INVITED EDOTAGroupMergeResult = 8 + EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_NOT_INVITED EDOTAGroupMergeResult = 9 +) + +var EDOTAGroupMergeResult_name = map[int32]string{ + 0: "k_EDOTAGroupMergeResult_OK", + 1: "k_EDOTAGroupMergeResult_FAILED_GENERIC", + 2: "k_EDOTAGroupMergeResult_NOT_LEADER", + 3: "k_EDOTAGroupMergeResult_TOO_MANY_PLAYERS", + 4: "k_EDOTAGroupMergeResult_TOO_MANY_COACHES", + 5: "k_EDOTAGroupMergeResult_ENGINE_MISMATCH", + 6: "k_EDOTAGroupMergeResult_NO_SUCH_GROUP", + 7: "k_EDOTAGroupMergeResult_OTHER_GROUP_NOT_OPEN", + 8: "k_EDOTAGroupMergeResult_ALREADY_INVITED", + 9: "k_EDOTAGroupMergeResult_NOT_INVITED", +} +var EDOTAGroupMergeResult_value = map[string]int32{ + "k_EDOTAGroupMergeResult_OK": 0, + "k_EDOTAGroupMergeResult_FAILED_GENERIC": 1, + "k_EDOTAGroupMergeResult_NOT_LEADER": 2, + "k_EDOTAGroupMergeResult_TOO_MANY_PLAYERS": 3, + "k_EDOTAGroupMergeResult_TOO_MANY_COACHES": 4, + "k_EDOTAGroupMergeResult_ENGINE_MISMATCH": 5, + "k_EDOTAGroupMergeResult_NO_SUCH_GROUP": 6, + "k_EDOTAGroupMergeResult_OTHER_GROUP_NOT_OPEN": 7, + "k_EDOTAGroupMergeResult_ALREADY_INVITED": 8, + "k_EDOTAGroupMergeResult_NOT_INVITED": 9, +} + +func (x EDOTAGroupMergeResult) Enum() *EDOTAGroupMergeResult { + p := new(EDOTAGroupMergeResult) + *p = x + return p +} +func (x EDOTAGroupMergeResult) String() string { + return proto.EnumName(EDOTAGroupMergeResult_name, int32(x)) +} +func (x *EDOTAGroupMergeResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EDOTAGroupMergeResult_value, data, "EDOTAGroupMergeResult") + if err != nil { + return err + } + *x = EDOTAGroupMergeResult(value) + return nil +} +func (EDOTAGroupMergeResult) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{6} } + +type CMsgDOTAMatch_ReplayState int32 + +const ( + CMsgDOTAMatch_REPLAY_AVAILABLE CMsgDOTAMatch_ReplayState = 0 + CMsgDOTAMatch_REPLAY_NOT_RECORDED CMsgDOTAMatch_ReplayState = 1 + CMsgDOTAMatch_REPLAY_EXPIRED CMsgDOTAMatch_ReplayState = 2 +) + +var CMsgDOTAMatch_ReplayState_name = map[int32]string{ + 0: "REPLAY_AVAILABLE", + 1: "REPLAY_NOT_RECORDED", + 2: "REPLAY_EXPIRED", +} +var CMsgDOTAMatch_ReplayState_value = map[string]int32{ + "REPLAY_AVAILABLE": 0, + "REPLAY_NOT_RECORDED": 1, + "REPLAY_EXPIRED": 2, +} + +func (x CMsgDOTAMatch_ReplayState) Enum() *CMsgDOTAMatch_ReplayState { + p := new(CMsgDOTAMatch_ReplayState) + *p = x + return p +} +func (x CMsgDOTAMatch_ReplayState) String() string { + return proto.EnumName(CMsgDOTAMatch_ReplayState_name, int32(x)) +} +func (x *CMsgDOTAMatch_ReplayState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAMatch_ReplayState_value, data, "CMsgDOTAMatch_ReplayState") + if err != nil { + return err + } + *x = CMsgDOTAMatch_ReplayState(value) + return nil +} +func (CMsgDOTAMatch_ReplayState) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{58, 0} +} + +type CMsgDOTARequestMatches_SkillLevel int32 + +const ( + CMsgDOTARequestMatches_Any CMsgDOTARequestMatches_SkillLevel = 0 + CMsgDOTARequestMatches_Normal CMsgDOTARequestMatches_SkillLevel = 1 + CMsgDOTARequestMatches_High CMsgDOTARequestMatches_SkillLevel = 2 + CMsgDOTARequestMatches_VeryHigh CMsgDOTARequestMatches_SkillLevel = 3 +) + +var CMsgDOTARequestMatches_SkillLevel_name = map[int32]string{ + 0: "Any", + 1: "Normal", + 2: "High", + 3: "VeryHigh", +} +var CMsgDOTARequestMatches_SkillLevel_value = map[string]int32{ + "Any": 0, + "Normal": 1, + "High": 2, + "VeryHigh": 3, +} + +func (x CMsgDOTARequestMatches_SkillLevel) Enum() *CMsgDOTARequestMatches_SkillLevel { + p := new(CMsgDOTARequestMatches_SkillLevel) + *p = x + return p +} +func (x CMsgDOTARequestMatches_SkillLevel) String() string { + return proto.EnumName(CMsgDOTARequestMatches_SkillLevel_name, int32(x)) +} +func (x *CMsgDOTARequestMatches_SkillLevel) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTARequestMatches_SkillLevel_value, data, "CMsgDOTARequestMatches_SkillLevel") + if err != nil { + return err + } + *x = CMsgDOTARequestMatches_SkillLevel(value) + return nil +} +func (CMsgDOTARequestMatches_SkillLevel) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{62, 0} +} + +type CMsgDOTAPopup_PopupID int32 + +const ( + CMsgDOTAPopup_KICKED_FROM_LOBBY CMsgDOTAPopup_PopupID = 0 + CMsgDOTAPopup_KICKED_FROM_PARTY CMsgDOTAPopup_PopupID = 1 + CMsgDOTAPopup_KICKED_FROM_TEAM CMsgDOTAPopup_PopupID = 2 + CMsgDOTAPopup_TEAM_WAS_DISBANDED CMsgDOTAPopup_PopupID = 3 + CMsgDOTAPopup_TEAM_MATCHMAKE_ALREADY_MATCH CMsgDOTAPopup_PopupID = 4 + CMsgDOTAPopup_TEAM_MATCHMAKE_ALREADY_FINDING CMsgDOTAPopup_PopupID = 5 + CMsgDOTAPopup_TEAM_MATCHMAKE_FULL CMsgDOTAPopup_PopupID = 6 + CMsgDOTAPopup_TEAM_MATCHMAKE_FAIL_ADD CMsgDOTAPopup_PopupID = 7 + CMsgDOTAPopup_TEAM_MATCHMAKE_FAIL_ADD_CURRENT CMsgDOTAPopup_PopupID = 8 + CMsgDOTAPopup_TEAM_MATCHMAKE_FAILED_TEAM_MEMBER CMsgDOTAPopup_PopupID = 9 + CMsgDOTAPopup_TEAM_MATCHMAKE_ALREADY_GAME CMsgDOTAPopup_PopupID = 10 + CMsgDOTAPopup_TEAM_MATCHMAKE_FAIL_GET_PARTY CMsgDOTAPopup_PopupID = 11 + CMsgDOTAPopup_MATCHMAKING_DISABLED CMsgDOTAPopup_PopupID = 12 + CMsgDOTAPopup_INVITE_DENIED CMsgDOTAPopup_PopupID = 13 + CMsgDOTAPopup_PARTY_FULL CMsgDOTAPopup_PopupID = 14 + CMsgDOTAPopup_MADE_ADMIN CMsgDOTAPopup_PopupID = 15 + CMsgDOTAPopup_NEED_TO_PURCHASE CMsgDOTAPopup_PopupID = 16 + CMsgDOTAPopup_SIGNON_MESSAGE CMsgDOTAPopup_PopupID = 17 + CMsgDOTAPopup_GUILD_KICKED CMsgDOTAPopup_PopupID = 18 + CMsgDOTAPopup_MATCHMAKING_REGION_OFFLINE CMsgDOTAPopup_PopupID = 19 + CMsgDOTAPopup_TOO_MANY_MATCHGROUPS CMsgDOTAPopup_PopupID = 20 + CMsgDOTAPopup_TOURNAMENT_GAME_NOT_FOUND CMsgDOTAPopup_PopupID = 21 + CMsgDOTAPopup_TOURNAMENT_GAME_HAS_LOBBY_ID CMsgDOTAPopup_PopupID = 22 + CMsgDOTAPopup_TOURNAMENT_GAME_HAS_MATCH_ID CMsgDOTAPopup_PopupID = 23 + CMsgDOTAPopup_TOURNAMENT_GAME_HAS_NO_RADIANT_TEAM CMsgDOTAPopup_PopupID = 24 + CMsgDOTAPopup_TOURNAMENT_GAME_HAS_NO_DIRE_TEAM CMsgDOTAPopup_PopupID = 25 + CMsgDOTAPopup_TOURNAMENT_GAME_SQL_UPDATE_FAILED CMsgDOTAPopup_PopupID = 26 + CMsgDOTAPopup_NOT_LEAGUE_ADMIN CMsgDOTAPopup_PopupID = 27 + CMsgDOTAPopup_PARTY_NOT_VALID_TO_MM CMsgDOTAPopup_PopupID = 28 + CMsgDOTAPopup_PARTY_NOT_VALID_TO_MM_COACHCOUNT CMsgDOTAPopup_PopupID = 29 + CMsgDOTAPopup_PARTY_MEMBER_IN_ANOTHER_GAME CMsgDOTAPopup_PopupID = 30 + CMsgDOTAPopup_PARTY_MEMBER_IN_LOW_PRIORITY CMsgDOTAPopup_PopupID = 31 + CMsgDOTAPopup_CLIENT_OUT_OF_DATE CMsgDOTAPopup_PopupID = 32 + CMsgDOTAPopup_COMPETITIVE_MM_NO_COACHES CMsgDOTAPopup_PopupID = 33 + CMsgDOTAPopup_COMPETITIVE_MM_NO_LOW_PRIORITY CMsgDOTAPopup_PopupID = 34 + CMsgDOTAPopup_COMPETITIVE_MM_NOT_UNLOCKED CMsgDOTAPopup_PopupID = 35 + CMsgDOTAPopup_COMPETITIVE_MM_GAME_MODE_NOT_ALLOWED CMsgDOTAPopup_PopupID = 36 + CMsgDOTAPopup_GAME_MODE_NOT_UNLOCKED CMsgDOTAPopup_PopupID = 37 + CMsgDOTAPopup_SAVE_GAME_CORRUPT CMsgDOTAPopup_PopupID = 38 + CMsgDOTAPopup_INSUFFICIENT_INGOTS CMsgDOTAPopup_PopupID = 39 + CMsgDOTAPopup_COMPETITIVE_MM_NO_4STACKS CMsgDOTAPopup_PopupID = 40 + CMsgDOTAPopup_COMPETITIVE_MM_PARTY_MMR_SPREAD_TOO_LARGE CMsgDOTAPopup_PopupID = 41 + CMsgDOTAPopup_COMPETITIVE_MM_NOT_ENOUGH_SKILL_DATA_PLAY_MORE_CASUAL CMsgDOTAPopup_PopupID = 42 + CMsgDOTAPopup_COMPETITIVE_MM_NOT_ENOUGH_SKILL_DATA_IN_PARTY CMsgDOTAPopup_PopupID = 43 + CMsgDOTAPopup_PARTY_LEADER_JOINED_LOBBY CMsgDOTAPopup_PopupID = 44 + CMsgDOTAPopup_MM_1V1_NO_PARTIES CMsgDOTAPopup_PopupID = 45 + CMsgDOTAPopup_MM_1V1_NO_LOW_PRIORITY CMsgDOTAPopup_PopupID = 46 + CMsgDOTAPopup_WEEKEND_TOURNEY_REGISTRATION_NOT_OPEN CMsgDOTAPopup_PopupID = 47 + CMsgDOTAPopup_WEEKEND_TOURNEY_UNMATCHED CMsgDOTAPopup_PopupID = 48 + CMsgDOTAPopup_POST_MATCH_SURVEY CMsgDOTAPopup_PopupID = 49 + CMsgDOTAPopup_TROPHY_AWARDED CMsgDOTAPopup_PopupID = 50 + CMsgDOTAPopup_TROPHY_LEVEL_UP CMsgDOTAPopup_PopupID = 51 + CMsgDOTAPopup_ALL_HERO_CHALLENGE_PROGRESS CMsgDOTAPopup_PopupID = 52 + CMsgDOTAPopup_NEED_INITIAL_SKILL CMsgDOTAPopup_PopupID = 53 + CMsgDOTAPopup_NEED_INITIAL_SKILL_IN_PARTY CMsgDOTAPopup_PopupID = 54 + CMsgDOTAPopup_TARGET_ENGINE_MISMATCH CMsgDOTAPopup_PopupID = 55 + CMsgDOTAPopup_VAC_NOT_VERIFIED CMsgDOTAPopup_PopupID = 56 + CMsgDOTAPopup_KICKED_FROM_QUEUE_EVENT_STARTING CMsgDOTAPopup_PopupID = 57 + CMsgDOTAPopup_KICKED_FROM_QUEUE_EVENT_ENDING CMsgDOTAPopup_PopupID = 58 + CMsgDOTAPopup_EVENT_NO_LOW_PRIORITY CMsgDOTAPopup_PopupID = 59 + CMsgDOTAPopup_MM_LOW_PRI_ONLY_CASUAL_AR CMsgDOTAPopup_PopupID = 60 + CMsgDOTAPopup_CNY2015_ONCE_PER_ROUND CMsgDOTAPopup_PopupID = 61 + CMsgDOTAPopup_LOBBY_FULL CMsgDOTAPopup_PopupID = 62 + CMsgDOTAPopup_EVENT_POINTS_EARNED CMsgDOTAPopup_PopupID = 63 + CMsgDOTAPopup_CUSTOM_GAME_INCORRECT_VERSION CMsgDOTAPopup_PopupID = 64 + CMsgDOTAPopup_COMPETITIVE_MM_MMR_TOO_HIGH_S2 CMsgDOTAPopup_PopupID = 65 + CMsgDOTAPopup_LIMITED_USER_CHAT CMsgDOTAPopup_PopupID = 66 + CMsgDOTAPopup_EVENT_PREMIUM_POINTS_EARNED CMsgDOTAPopup_PopupID = 67 +) + +var CMsgDOTAPopup_PopupID_name = map[int32]string{ + 0: "KICKED_FROM_LOBBY", + 1: "KICKED_FROM_PARTY", + 2: "KICKED_FROM_TEAM", + 3: "TEAM_WAS_DISBANDED", + 4: "TEAM_MATCHMAKE_ALREADY_MATCH", + 5: "TEAM_MATCHMAKE_ALREADY_FINDING", + 6: "TEAM_MATCHMAKE_FULL", + 7: "TEAM_MATCHMAKE_FAIL_ADD", + 8: "TEAM_MATCHMAKE_FAIL_ADD_CURRENT", + 9: "TEAM_MATCHMAKE_FAILED_TEAM_MEMBER", + 10: "TEAM_MATCHMAKE_ALREADY_GAME", + 11: "TEAM_MATCHMAKE_FAIL_GET_PARTY", + 12: "MATCHMAKING_DISABLED", + 13: "INVITE_DENIED", + 14: "PARTY_FULL", + 15: "MADE_ADMIN", + 16: "NEED_TO_PURCHASE", + 17: "SIGNON_MESSAGE", + 18: "GUILD_KICKED", + 19: "MATCHMAKING_REGION_OFFLINE", + 20: "TOO_MANY_MATCHGROUPS", + 21: "TOURNAMENT_GAME_NOT_FOUND", + 22: "TOURNAMENT_GAME_HAS_LOBBY_ID", + 23: "TOURNAMENT_GAME_HAS_MATCH_ID", + 24: "TOURNAMENT_GAME_HAS_NO_RADIANT_TEAM", + 25: "TOURNAMENT_GAME_HAS_NO_DIRE_TEAM", + 26: "TOURNAMENT_GAME_SQL_UPDATE_FAILED", + 27: "NOT_LEAGUE_ADMIN", + 28: "PARTY_NOT_VALID_TO_MM", + 29: "PARTY_NOT_VALID_TO_MM_COACHCOUNT", + 30: "PARTY_MEMBER_IN_ANOTHER_GAME", + 31: "PARTY_MEMBER_IN_LOW_PRIORITY", + 32: "CLIENT_OUT_OF_DATE", + 33: "COMPETITIVE_MM_NO_COACHES", + 34: "COMPETITIVE_MM_NO_LOW_PRIORITY", + 35: "COMPETITIVE_MM_NOT_UNLOCKED", + 36: "COMPETITIVE_MM_GAME_MODE_NOT_ALLOWED", + 37: "GAME_MODE_NOT_UNLOCKED", + 38: "SAVE_GAME_CORRUPT", + 39: "INSUFFICIENT_INGOTS", + 40: "COMPETITIVE_MM_NO_4STACKS", + 41: "COMPETITIVE_MM_PARTY_MMR_SPREAD_TOO_LARGE", + 42: "COMPETITIVE_MM_NOT_ENOUGH_SKILL_DATA_PLAY_MORE_CASUAL", + 43: "COMPETITIVE_MM_NOT_ENOUGH_SKILL_DATA_IN_PARTY", + 44: "PARTY_LEADER_JOINED_LOBBY", + 45: "MM_1V1_NO_PARTIES", + 46: "MM_1V1_NO_LOW_PRIORITY", + 47: "WEEKEND_TOURNEY_REGISTRATION_NOT_OPEN", + 48: "WEEKEND_TOURNEY_UNMATCHED", + 49: "POST_MATCH_SURVEY", + 50: "TROPHY_AWARDED", + 51: "TROPHY_LEVEL_UP", + 52: "ALL_HERO_CHALLENGE_PROGRESS", + 53: "NEED_INITIAL_SKILL", + 54: "NEED_INITIAL_SKILL_IN_PARTY", + 55: "TARGET_ENGINE_MISMATCH", + 56: "VAC_NOT_VERIFIED", + 57: "KICKED_FROM_QUEUE_EVENT_STARTING", + 58: "KICKED_FROM_QUEUE_EVENT_ENDING", + 59: "EVENT_NO_LOW_PRIORITY", + 60: "MM_LOW_PRI_ONLY_CASUAL_AR", + 61: "CNY2015_ONCE_PER_ROUND", + 62: "LOBBY_FULL", + 63: "EVENT_POINTS_EARNED", + 64: "CUSTOM_GAME_INCORRECT_VERSION", + 65: "COMPETITIVE_MM_MMR_TOO_HIGH_S2", + 66: "LIMITED_USER_CHAT", + 67: "EVENT_PREMIUM_POINTS_EARNED", +} +var CMsgDOTAPopup_PopupID_value = map[string]int32{ + "KICKED_FROM_LOBBY": 0, + "KICKED_FROM_PARTY": 1, + "KICKED_FROM_TEAM": 2, + "TEAM_WAS_DISBANDED": 3, + "TEAM_MATCHMAKE_ALREADY_MATCH": 4, + "TEAM_MATCHMAKE_ALREADY_FINDING": 5, + "TEAM_MATCHMAKE_FULL": 6, + "TEAM_MATCHMAKE_FAIL_ADD": 7, + "TEAM_MATCHMAKE_FAIL_ADD_CURRENT": 8, + "TEAM_MATCHMAKE_FAILED_TEAM_MEMBER": 9, + "TEAM_MATCHMAKE_ALREADY_GAME": 10, + "TEAM_MATCHMAKE_FAIL_GET_PARTY": 11, + "MATCHMAKING_DISABLED": 12, + "INVITE_DENIED": 13, + "PARTY_FULL": 14, + "MADE_ADMIN": 15, + "NEED_TO_PURCHASE": 16, + "SIGNON_MESSAGE": 17, + "GUILD_KICKED": 18, + "MATCHMAKING_REGION_OFFLINE": 19, + "TOO_MANY_MATCHGROUPS": 20, + "TOURNAMENT_GAME_NOT_FOUND": 21, + "TOURNAMENT_GAME_HAS_LOBBY_ID": 22, + "TOURNAMENT_GAME_HAS_MATCH_ID": 23, + "TOURNAMENT_GAME_HAS_NO_RADIANT_TEAM": 24, + "TOURNAMENT_GAME_HAS_NO_DIRE_TEAM": 25, + "TOURNAMENT_GAME_SQL_UPDATE_FAILED": 26, + "NOT_LEAGUE_ADMIN": 27, + "PARTY_NOT_VALID_TO_MM": 28, + "PARTY_NOT_VALID_TO_MM_COACHCOUNT": 29, + "PARTY_MEMBER_IN_ANOTHER_GAME": 30, + "PARTY_MEMBER_IN_LOW_PRIORITY": 31, + "CLIENT_OUT_OF_DATE": 32, + "COMPETITIVE_MM_NO_COACHES": 33, + "COMPETITIVE_MM_NO_LOW_PRIORITY": 34, + "COMPETITIVE_MM_NOT_UNLOCKED": 35, + "COMPETITIVE_MM_GAME_MODE_NOT_ALLOWED": 36, + "GAME_MODE_NOT_UNLOCKED": 37, + "SAVE_GAME_CORRUPT": 38, + "INSUFFICIENT_INGOTS": 39, + "COMPETITIVE_MM_NO_4STACKS": 40, + "COMPETITIVE_MM_PARTY_MMR_SPREAD_TOO_LARGE": 41, + "COMPETITIVE_MM_NOT_ENOUGH_SKILL_DATA_PLAY_MORE_CASUAL": 42, + "COMPETITIVE_MM_NOT_ENOUGH_SKILL_DATA_IN_PARTY": 43, + "PARTY_LEADER_JOINED_LOBBY": 44, + "MM_1V1_NO_PARTIES": 45, + "MM_1V1_NO_LOW_PRIORITY": 46, + "WEEKEND_TOURNEY_REGISTRATION_NOT_OPEN": 47, + "WEEKEND_TOURNEY_UNMATCHED": 48, + "POST_MATCH_SURVEY": 49, + "TROPHY_AWARDED": 50, + "TROPHY_LEVEL_UP": 51, + "ALL_HERO_CHALLENGE_PROGRESS": 52, + "NEED_INITIAL_SKILL": 53, + "NEED_INITIAL_SKILL_IN_PARTY": 54, + "TARGET_ENGINE_MISMATCH": 55, + "VAC_NOT_VERIFIED": 56, + "KICKED_FROM_QUEUE_EVENT_STARTING": 57, + "KICKED_FROM_QUEUE_EVENT_ENDING": 58, + "EVENT_NO_LOW_PRIORITY": 59, + "MM_LOW_PRI_ONLY_CASUAL_AR": 60, + "CNY2015_ONCE_PER_ROUND": 61, + "LOBBY_FULL": 62, + "EVENT_POINTS_EARNED": 63, + "CUSTOM_GAME_INCORRECT_VERSION": 64, + "COMPETITIVE_MM_MMR_TOO_HIGH_S2": 65, + "LIMITED_USER_CHAT": 66, + "EVENT_PREMIUM_POINTS_EARNED": 67, +} + +func (x CMsgDOTAPopup_PopupID) Enum() *CMsgDOTAPopup_PopupID { + p := new(CMsgDOTAPopup_PopupID) + *p = x + return p +} +func (x CMsgDOTAPopup_PopupID) String() string { + return proto.EnumName(CMsgDOTAPopup_PopupID_name, int32(x)) +} +func (x *CMsgDOTAPopup_PopupID) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAPopup_PopupID_value, data, "CMsgDOTAPopup_PopupID") + if err != nil { + return err + } + *x = CMsgDOTAPopup_PopupID(value) + return nil +} +func (CMsgDOTAPopup_PopupID) EnumDescriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{64, 0} } + +type CMsgDOTACreateTeamResponse_Result int32 + +const ( + CMsgDOTACreateTeamResponse_INVALID CMsgDOTACreateTeamResponse_Result = -1 + CMsgDOTACreateTeamResponse_SUCCESS CMsgDOTACreateTeamResponse_Result = 0 + CMsgDOTACreateTeamResponse_NAME_EMPTY CMsgDOTACreateTeamResponse_Result = 1 + CMsgDOTACreateTeamResponse_NAME_BAD_CHARACTERS CMsgDOTACreateTeamResponse_Result = 2 + CMsgDOTACreateTeamResponse_NAME_TAKEN CMsgDOTACreateTeamResponse_Result = 3 + CMsgDOTACreateTeamResponse_NAME_TOO_LONG CMsgDOTACreateTeamResponse_Result = 4 + CMsgDOTACreateTeamResponse_TAG_EMPTY CMsgDOTACreateTeamResponse_Result = 5 + CMsgDOTACreateTeamResponse_TAG_BAD_CHARACTERS CMsgDOTACreateTeamResponse_Result = 6 + CMsgDOTACreateTeamResponse_TAG_TAKEN CMsgDOTACreateTeamResponse_Result = 7 + CMsgDOTACreateTeamResponse_TAG_TOO_LONG CMsgDOTACreateTeamResponse_Result = 8 + CMsgDOTACreateTeamResponse_CREATOR_BUSY CMsgDOTACreateTeamResponse_Result = 9 + CMsgDOTACreateTeamResponse_UNSPECIFIED_ERROR CMsgDOTACreateTeamResponse_Result = 10 + CMsgDOTACreateTeamResponse_CREATOR_TEAM_LIMIT_REACHED CMsgDOTACreateTeamResponse_Result = 11 + CMsgDOTACreateTeamResponse_NO_LOGO CMsgDOTACreateTeamResponse_Result = 12 + CMsgDOTACreateTeamResponse_CREATOR_TEAM_CREATION_COOLDOWN CMsgDOTACreateTeamResponse_Result = 13 + CMsgDOTACreateTeamResponse_LOGO_UPLOAD_FAILED CMsgDOTACreateTeamResponse_Result = 14 + CMsgDOTACreateTeamResponse_NAME_CHANGED_TOO_RECENTLY CMsgDOTACreateTeamResponse_Result = 15 + CMsgDOTACreateTeamResponse_CREATOR_INSUFFICIENT_LEVEL CMsgDOTACreateTeamResponse_Result = 16 +) + +var CMsgDOTACreateTeamResponse_Result_name = map[int32]string{ + -1: "INVALID", + 0: "SUCCESS", + 1: "NAME_EMPTY", + 2: "NAME_BAD_CHARACTERS", + 3: "NAME_TAKEN", + 4: "NAME_TOO_LONG", + 5: "TAG_EMPTY", + 6: "TAG_BAD_CHARACTERS", + 7: "TAG_TAKEN", + 8: "TAG_TOO_LONG", + 9: "CREATOR_BUSY", + 10: "UNSPECIFIED_ERROR", + 11: "CREATOR_TEAM_LIMIT_REACHED", + 12: "NO_LOGO", + 13: "CREATOR_TEAM_CREATION_COOLDOWN", + 14: "LOGO_UPLOAD_FAILED", + 15: "NAME_CHANGED_TOO_RECENTLY", + 16: "CREATOR_INSUFFICIENT_LEVEL", +} +var CMsgDOTACreateTeamResponse_Result_value = map[string]int32{ + "INVALID": -1, + "SUCCESS": 0, + "NAME_EMPTY": 1, + "NAME_BAD_CHARACTERS": 2, + "NAME_TAKEN": 3, + "NAME_TOO_LONG": 4, + "TAG_EMPTY": 5, + "TAG_BAD_CHARACTERS": 6, + "TAG_TAKEN": 7, + "TAG_TOO_LONG": 8, + "CREATOR_BUSY": 9, + "UNSPECIFIED_ERROR": 10, + "CREATOR_TEAM_LIMIT_REACHED": 11, + "NO_LOGO": 12, + "CREATOR_TEAM_CREATION_COOLDOWN": 13, + "LOGO_UPLOAD_FAILED": 14, + "NAME_CHANGED_TOO_RECENTLY": 15, + "CREATOR_INSUFFICIENT_LEVEL": 16, +} + +func (x CMsgDOTACreateTeamResponse_Result) Enum() *CMsgDOTACreateTeamResponse_Result { + p := new(CMsgDOTACreateTeamResponse_Result) + *p = x + return p +} +func (x CMsgDOTACreateTeamResponse_Result) String() string { + return proto.EnumName(CMsgDOTACreateTeamResponse_Result_name, int32(x)) +} +func (x *CMsgDOTACreateTeamResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTACreateTeamResponse_Result_value, data, "CMsgDOTACreateTeamResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTACreateTeamResponse_Result(value) + return nil +} +func (CMsgDOTACreateTeamResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{70, 0} +} + +type CMsgDOTAEditTeamLogoResponse_Result int32 + +const ( + CMsgDOTAEditTeamLogoResponse_INVALID CMsgDOTAEditTeamLogoResponse_Result = -1 + CMsgDOTAEditTeamLogoResponse_SUCCESS CMsgDOTAEditTeamLogoResponse_Result = 0 + CMsgDOTAEditTeamLogoResponse_CREATOR_BUSY CMsgDOTAEditTeamLogoResponse_Result = 9 + CMsgDOTAEditTeamLogoResponse_UNSPECIFIED_ERROR CMsgDOTAEditTeamLogoResponse_Result = 10 + CMsgDOTAEditTeamLogoResponse_NO_LOGO CMsgDOTAEditTeamLogoResponse_Result = 12 +) + +var CMsgDOTAEditTeamLogoResponse_Result_name = map[int32]string{ + -1: "INVALID", + 0: "SUCCESS", + 9: "CREATOR_BUSY", + 10: "UNSPECIFIED_ERROR", + 12: "NO_LOGO", +} +var CMsgDOTAEditTeamLogoResponse_Result_value = map[string]int32{ + "INVALID": -1, + "SUCCESS": 0, + "CREATOR_BUSY": 9, + "UNSPECIFIED_ERROR": 10, + "NO_LOGO": 12, +} + +func (x CMsgDOTAEditTeamLogoResponse_Result) Enum() *CMsgDOTAEditTeamLogoResponse_Result { + p := new(CMsgDOTAEditTeamLogoResponse_Result) + *p = x + return p +} +func (x CMsgDOTAEditTeamLogoResponse_Result) String() string { + return proto.EnumName(CMsgDOTAEditTeamLogoResponse_Result_name, int32(x)) +} +func (x *CMsgDOTAEditTeamLogoResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAEditTeamLogoResponse_Result_value, data, "CMsgDOTAEditTeamLogoResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTAEditTeamLogoResponse_Result(value) + return nil +} +func (CMsgDOTAEditTeamLogoResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{73, 0} +} + +type CMsgDOTAEditTeamDetailsResponse_Result int32 + +const ( + CMsgDOTAEditTeamDetailsResponse_INVALID CMsgDOTAEditTeamDetailsResponse_Result = -1 + CMsgDOTAEditTeamDetailsResponse_SUCCESS CMsgDOTAEditTeamDetailsResponse_Result = 0 + CMsgDOTAEditTeamDetailsResponse_CREATOR_BUSY CMsgDOTAEditTeamDetailsResponse_Result = 9 + CMsgDOTAEditTeamDetailsResponse_UNSPECIFIED_ERROR CMsgDOTAEditTeamDetailsResponse_Result = 10 +) + +var CMsgDOTAEditTeamDetailsResponse_Result_name = map[int32]string{ + -1: "INVALID", + 0: "SUCCESS", + 9: "CREATOR_BUSY", + 10: "UNSPECIFIED_ERROR", +} +var CMsgDOTAEditTeamDetailsResponse_Result_value = map[string]int32{ + "INVALID": -1, + "SUCCESS": 0, + "CREATOR_BUSY": 9, + "UNSPECIFIED_ERROR": 10, +} + +func (x CMsgDOTAEditTeamDetailsResponse_Result) Enum() *CMsgDOTAEditTeamDetailsResponse_Result { + p := new(CMsgDOTAEditTeamDetailsResponse_Result) + *p = x + return p +} +func (x CMsgDOTAEditTeamDetailsResponse_Result) String() string { + return proto.EnumName(CMsgDOTAEditTeamDetailsResponse_Result_name, int32(x)) +} +func (x *CMsgDOTAEditTeamDetailsResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAEditTeamDetailsResponse_Result_value, data, "CMsgDOTAEditTeamDetailsResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTAEditTeamDetailsResponse_Result(value) + return nil +} +func (CMsgDOTAEditTeamDetailsResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{75, 0} +} + +type CMsgDOTADisbandTeamResponse_Result int32 + +const ( + CMsgDOTADisbandTeamResponse_SUCCESS CMsgDOTADisbandTeamResponse_Result = 0 + CMsgDOTADisbandTeamResponse_FAILURE CMsgDOTADisbandTeamResponse_Result = 1 + CMsgDOTADisbandTeamResponse_FAILURE_NOT_EMPTY CMsgDOTADisbandTeamResponse_Result = 2 +) + +var CMsgDOTADisbandTeamResponse_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "FAILURE", + 2: "FAILURE_NOT_EMPTY", +} +var CMsgDOTADisbandTeamResponse_Result_value = map[string]int32{ + "SUCCESS": 0, + "FAILURE": 1, + "FAILURE_NOT_EMPTY": 2, +} + +func (x CMsgDOTADisbandTeamResponse_Result) Enum() *CMsgDOTADisbandTeamResponse_Result { + p := new(CMsgDOTADisbandTeamResponse_Result) + *p = x + return p +} +func (x CMsgDOTADisbandTeamResponse_Result) String() string { + return proto.EnumName(CMsgDOTADisbandTeamResponse_Result_name, int32(x)) +} +func (x *CMsgDOTADisbandTeamResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTADisbandTeamResponse_Result_value, data, "CMsgDOTADisbandTeamResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTADisbandTeamResponse_Result(value) + return nil +} +func (CMsgDOTADisbandTeamResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{77, 0} +} + +type CMsgDOTARequestTeamDataResponse_Result int32 + +const ( + CMsgDOTARequestTeamDataResponse_SUCCESS CMsgDOTARequestTeamDataResponse_Result = 0 + CMsgDOTARequestTeamDataResponse_FAILURE CMsgDOTARequestTeamDataResponse_Result = 1 +) + +var CMsgDOTARequestTeamDataResponse_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "FAILURE", +} +var CMsgDOTARequestTeamDataResponse_Result_value = map[string]int32{ + "SUCCESS": 0, + "FAILURE": 1, +} + +func (x CMsgDOTARequestTeamDataResponse_Result) Enum() *CMsgDOTARequestTeamDataResponse_Result { + p := new(CMsgDOTARequestTeamDataResponse_Result) + *p = x + return p +} +func (x CMsgDOTARequestTeamDataResponse_Result) String() string { + return proto.EnumName(CMsgDOTARequestTeamDataResponse_Result_name, int32(x)) +} +func (x *CMsgDOTARequestTeamDataResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTARequestTeamDataResponse_Result_value, data, "CMsgDOTARequestTeamDataResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTARequestTeamDataResponse_Result(value) + return nil +} +func (CMsgDOTARequestTeamDataResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{79, 0} +} + +type CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result int32 + +const ( + CMsgDOTATeamInvite_GCImmediateResponseToInviter_SUCCESS CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 0 + CMsgDOTATeamInvite_GCImmediateResponseToInviter_MEMBER_LIMIT CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 1 + CMsgDOTATeamInvite_GCImmediateResponseToInviter_INVITEE_NOT_AVAILABLE CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 2 + CMsgDOTATeamInvite_GCImmediateResponseToInviter_INVITEE_BUSY CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 3 + CMsgDOTATeamInvite_GCImmediateResponseToInviter_INVITEE_ALREADY_ON_THE_TEAM CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 4 + CMsgDOTATeamInvite_GCImmediateResponseToInviter_INVITEE_ALREADY_ON_TOO_MANY_TEAMS CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 5 + CMsgDOTATeamInvite_GCImmediateResponseToInviter_UNSPECIFIED_ERROR CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 6 + CMsgDOTATeamInvite_GCImmediateResponseToInviter_INVITEE_INSUFFICIENT_LEVEL CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = 7 +) + +var CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "MEMBER_LIMIT", + 2: "INVITEE_NOT_AVAILABLE", + 3: "INVITEE_BUSY", + 4: "INVITEE_ALREADY_ON_THE_TEAM", + 5: "INVITEE_ALREADY_ON_TOO_MANY_TEAMS", + 6: "UNSPECIFIED_ERROR", + 7: "INVITEE_INSUFFICIENT_LEVEL", +} +var CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result_value = map[string]int32{ + "SUCCESS": 0, + "MEMBER_LIMIT": 1, + "INVITEE_NOT_AVAILABLE": 2, + "INVITEE_BUSY": 3, + "INVITEE_ALREADY_ON_THE_TEAM": 4, + "INVITEE_ALREADY_ON_TOO_MANY_TEAMS": 5, + "UNSPECIFIED_ERROR": 6, + "INVITEE_INSUFFICIENT_LEVEL": 7, +} + +func (x CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result) Enum() *CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result { + p := new(CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result) + *p = x + return p +} +func (x CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result) String() string { + return proto.EnumName(CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result_name, int32(x)) +} +func (x *CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result_value, data, "CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result") + if err != nil { + return err + } + *x = CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result(value) + return nil +} +func (CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{89, 0} +} + +type CMsgDOTATeamInvite_InviteeResponseToGC_Result int32 + +const ( + CMsgDOTATeamInvite_InviteeResponseToGC_JOIN CMsgDOTATeamInvite_InviteeResponseToGC_Result = 0 + CMsgDOTATeamInvite_InviteeResponseToGC_REJECT CMsgDOTATeamInvite_InviteeResponseToGC_Result = 1 + CMsgDOTATeamInvite_InviteeResponseToGC_TIMEOUT CMsgDOTATeamInvite_InviteeResponseToGC_Result = 2 +) + +var CMsgDOTATeamInvite_InviteeResponseToGC_Result_name = map[int32]string{ + 0: "JOIN", + 1: "REJECT", + 2: "TIMEOUT", +} +var CMsgDOTATeamInvite_InviteeResponseToGC_Result_value = map[string]int32{ + "JOIN": 0, + "REJECT": 1, + "TIMEOUT": 2, +} + +func (x CMsgDOTATeamInvite_InviteeResponseToGC_Result) Enum() *CMsgDOTATeamInvite_InviteeResponseToGC_Result { + p := new(CMsgDOTATeamInvite_InviteeResponseToGC_Result) + *p = x + return p +} +func (x CMsgDOTATeamInvite_InviteeResponseToGC_Result) String() string { + return proto.EnumName(CMsgDOTATeamInvite_InviteeResponseToGC_Result_name, int32(x)) +} +func (x *CMsgDOTATeamInvite_InviteeResponseToGC_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTATeamInvite_InviteeResponseToGC_Result_value, data, "CMsgDOTATeamInvite_InviteeResponseToGC_Result") + if err != nil { + return err + } + *x = CMsgDOTATeamInvite_InviteeResponseToGC_Result(value) + return nil +} +func (CMsgDOTATeamInvite_InviteeResponseToGC_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{91, 0} +} + +type CMsgDOTATeamInvite_GCResponseToInviter_Result int32 + +const ( + CMsgDOTATeamInvite_GCResponseToInviter_JOINED CMsgDOTATeamInvite_GCResponseToInviter_Result = 0 + CMsgDOTATeamInvite_GCResponseToInviter_REJECTION CMsgDOTATeamInvite_GCResponseToInviter_Result = 1 + CMsgDOTATeamInvite_GCResponseToInviter_TIMEOUT CMsgDOTATeamInvite_GCResponseToInviter_Result = 2 + CMsgDOTATeamInvite_GCResponseToInviter_UNSPECIFIED_ERROR CMsgDOTATeamInvite_GCResponseToInviter_Result = 3 +) + +var CMsgDOTATeamInvite_GCResponseToInviter_Result_name = map[int32]string{ + 0: "JOINED", + 1: "REJECTION", + 2: "TIMEOUT", + 3: "UNSPECIFIED_ERROR", +} +var CMsgDOTATeamInvite_GCResponseToInviter_Result_value = map[string]int32{ + "JOINED": 0, + "REJECTION": 1, + "TIMEOUT": 2, + "UNSPECIFIED_ERROR": 3, +} + +func (x CMsgDOTATeamInvite_GCResponseToInviter_Result) Enum() *CMsgDOTATeamInvite_GCResponseToInviter_Result { + p := new(CMsgDOTATeamInvite_GCResponseToInviter_Result) + *p = x + return p +} +func (x CMsgDOTATeamInvite_GCResponseToInviter_Result) String() string { + return proto.EnumName(CMsgDOTATeamInvite_GCResponseToInviter_Result_name, int32(x)) +} +func (x *CMsgDOTATeamInvite_GCResponseToInviter_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTATeamInvite_GCResponseToInviter_Result_value, data, "CMsgDOTATeamInvite_GCResponseToInviter_Result") + if err != nil { + return err + } + *x = CMsgDOTATeamInvite_GCResponseToInviter_Result(value) + return nil +} +func (CMsgDOTATeamInvite_GCResponseToInviter_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{92, 0} +} + +type CMsgDOTATeamInvite_GCResponseToInvitee_Result int32 + +const ( + CMsgDOTATeamInvite_GCResponseToInvitee_SUCCESS CMsgDOTATeamInvite_GCResponseToInvitee_Result = 0 + CMsgDOTATeamInvite_GCResponseToInvitee_FAILURE CMsgDOTATeamInvite_GCResponseToInvitee_Result = 1 +) + +var CMsgDOTATeamInvite_GCResponseToInvitee_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "FAILURE", +} +var CMsgDOTATeamInvite_GCResponseToInvitee_Result_value = map[string]int32{ + "SUCCESS": 0, + "FAILURE": 1, +} + +func (x CMsgDOTATeamInvite_GCResponseToInvitee_Result) Enum() *CMsgDOTATeamInvite_GCResponseToInvitee_Result { + p := new(CMsgDOTATeamInvite_GCResponseToInvitee_Result) + *p = x + return p +} +func (x CMsgDOTATeamInvite_GCResponseToInvitee_Result) String() string { + return proto.EnumName(CMsgDOTATeamInvite_GCResponseToInvitee_Result_name, int32(x)) +} +func (x *CMsgDOTATeamInvite_GCResponseToInvitee_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTATeamInvite_GCResponseToInvitee_Result_value, data, "CMsgDOTATeamInvite_GCResponseToInvitee_Result") + if err != nil { + return err + } + *x = CMsgDOTATeamInvite_GCResponseToInvitee_Result(value) + return nil +} +func (CMsgDOTATeamInvite_GCResponseToInvitee_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{93, 0} +} + +type CMsgDOTAKickTeamMemberResponse_Result int32 + +const ( + CMsgDOTAKickTeamMemberResponse_SUCCESS CMsgDOTAKickTeamMemberResponse_Result = 0 + CMsgDOTAKickTeamMemberResponse_FAILURE CMsgDOTAKickTeamMemberResponse_Result = 1 +) + +var CMsgDOTAKickTeamMemberResponse_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "FAILURE", +} +var CMsgDOTAKickTeamMemberResponse_Result_value = map[string]int32{ + "SUCCESS": 0, + "FAILURE": 1, +} + +func (x CMsgDOTAKickTeamMemberResponse_Result) Enum() *CMsgDOTAKickTeamMemberResponse_Result { + p := new(CMsgDOTAKickTeamMemberResponse_Result) + *p = x + return p +} +func (x CMsgDOTAKickTeamMemberResponse_Result) String() string { + return proto.EnumName(CMsgDOTAKickTeamMemberResponse_Result_name, int32(x)) +} +func (x *CMsgDOTAKickTeamMemberResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAKickTeamMemberResponse_Result_value, data, "CMsgDOTAKickTeamMemberResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTAKickTeamMemberResponse_Result(value) + return nil +} +func (CMsgDOTAKickTeamMemberResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{96, 0} +} + +type CMsgDOTATransferTeamAdminResponse_Result int32 + +const ( + CMsgDOTATransferTeamAdminResponse_SUCCESS CMsgDOTATransferTeamAdminResponse_Result = 0 + CMsgDOTATransferTeamAdminResponse_NOT_ADMIN CMsgDOTATransferTeamAdminResponse_Result = 1 + CMsgDOTATransferTeamAdminResponse_ON_OTHER_TEAM CMsgDOTATransferTeamAdminResponse_Result = 2 + CMsgDOTATransferTeamAdminResponse_ADMIN_OF_OTHER_TEAM CMsgDOTATransferTeamAdminResponse_Result = 3 + CMsgDOTATransferTeamAdminResponse_UNSPECIFIED_ERROR CMsgDOTATransferTeamAdminResponse_Result = 4 +) + +var CMsgDOTATransferTeamAdminResponse_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "NOT_ADMIN", + 2: "ON_OTHER_TEAM", + 3: "ADMIN_OF_OTHER_TEAM", + 4: "UNSPECIFIED_ERROR", +} +var CMsgDOTATransferTeamAdminResponse_Result_value = map[string]int32{ + "SUCCESS": 0, + "NOT_ADMIN": 1, + "ON_OTHER_TEAM": 2, + "ADMIN_OF_OTHER_TEAM": 3, + "UNSPECIFIED_ERROR": 4, +} + +func (x CMsgDOTATransferTeamAdminResponse_Result) Enum() *CMsgDOTATransferTeamAdminResponse_Result { + p := new(CMsgDOTATransferTeamAdminResponse_Result) + *p = x + return p +} +func (x CMsgDOTATransferTeamAdminResponse_Result) String() string { + return proto.EnumName(CMsgDOTATransferTeamAdminResponse_Result_name, int32(x)) +} +func (x *CMsgDOTATransferTeamAdminResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTATransferTeamAdminResponse_Result_value, data, "CMsgDOTATransferTeamAdminResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTATransferTeamAdminResponse_Result(value) + return nil +} +func (CMsgDOTATransferTeamAdminResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{98, 0} +} + +type CMsgDOTALeaveTeamResponse_Result int32 + +const ( + CMsgDOTALeaveTeamResponse_SUCCESS CMsgDOTALeaveTeamResponse_Result = 0 + CMsgDOTALeaveTeamResponse_FAILURE CMsgDOTALeaveTeamResponse_Result = 1 +) + +var CMsgDOTALeaveTeamResponse_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "FAILURE", +} +var CMsgDOTALeaveTeamResponse_Result_value = map[string]int32{ + "SUCCESS": 0, + "FAILURE": 1, +} + +func (x CMsgDOTALeaveTeamResponse_Result) Enum() *CMsgDOTALeaveTeamResponse_Result { + p := new(CMsgDOTALeaveTeamResponse_Result) + *p = x + return p +} +func (x CMsgDOTALeaveTeamResponse_Result) String() string { + return proto.EnumName(CMsgDOTALeaveTeamResponse_Result_name, int32(x)) +} +func (x *CMsgDOTALeaveTeamResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTALeaveTeamResponse_Result_value, data, "CMsgDOTALeaveTeamResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTALeaveTeamResponse_Result(value) + return nil +} +func (CMsgDOTALeaveTeamResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{100, 0} +} + +type CMsgDOTAJoinChatChannelResponse_Result int32 + +const ( + CMsgDOTAJoinChatChannelResponse_JOIN_SUCCESS CMsgDOTAJoinChatChannelResponse_Result = 0 + CMsgDOTAJoinChatChannelResponse_INVALID_CHANNEL_TYPE CMsgDOTAJoinChatChannelResponse_Result = 1 + CMsgDOTAJoinChatChannelResponse_ACCOUNT_NOT_FOUND CMsgDOTAJoinChatChannelResponse_Result = 2 + CMsgDOTAJoinChatChannelResponse_ACH_FAILED CMsgDOTAJoinChatChannelResponse_Result = 3 + CMsgDOTAJoinChatChannelResponse_USER_IN_TOO_MANY_CHANNELS CMsgDOTAJoinChatChannelResponse_Result = 4 + CMsgDOTAJoinChatChannelResponse_RATE_LIMIT_EXCEEDED CMsgDOTAJoinChatChannelResponse_Result = 5 + CMsgDOTAJoinChatChannelResponse_CHANNEL_FULL CMsgDOTAJoinChatChannelResponse_Result = 6 + CMsgDOTAJoinChatChannelResponse_CHANNEL_FULL_OVERFLOWED CMsgDOTAJoinChatChannelResponse_Result = 7 + CMsgDOTAJoinChatChannelResponse_FAILED_TO_ADD_USER CMsgDOTAJoinChatChannelResponse_Result = 8 + CMsgDOTAJoinChatChannelResponse_CHANNEL_TYPE_DISABLED CMsgDOTAJoinChatChannelResponse_Result = 9 + CMsgDOTAJoinChatChannelResponse_PRIVATE_CHAT_CREATE_FAILED CMsgDOTAJoinChatChannelResponse_Result = 10 + CMsgDOTAJoinChatChannelResponse_PRIVATE_CHAT_NO_PERMISSION CMsgDOTAJoinChatChannelResponse_Result = 11 + CMsgDOTAJoinChatChannelResponse_PRIVATE_CHAT_CREATE_LOCK_FAILED CMsgDOTAJoinChatChannelResponse_Result = 12 + CMsgDOTAJoinChatChannelResponse_PRIVATE_CHAT_KICKED CMsgDOTAJoinChatChannelResponse_Result = 13 +) + +var CMsgDOTAJoinChatChannelResponse_Result_name = map[int32]string{ + 0: "JOIN_SUCCESS", + 1: "INVALID_CHANNEL_TYPE", + 2: "ACCOUNT_NOT_FOUND", + 3: "ACH_FAILED", + 4: "USER_IN_TOO_MANY_CHANNELS", + 5: "RATE_LIMIT_EXCEEDED", + 6: "CHANNEL_FULL", + 7: "CHANNEL_FULL_OVERFLOWED", + 8: "FAILED_TO_ADD_USER", + 9: "CHANNEL_TYPE_DISABLED", + 10: "PRIVATE_CHAT_CREATE_FAILED", + 11: "PRIVATE_CHAT_NO_PERMISSION", + 12: "PRIVATE_CHAT_CREATE_LOCK_FAILED", + 13: "PRIVATE_CHAT_KICKED", +} +var CMsgDOTAJoinChatChannelResponse_Result_value = map[string]int32{ + "JOIN_SUCCESS": 0, + "INVALID_CHANNEL_TYPE": 1, + "ACCOUNT_NOT_FOUND": 2, + "ACH_FAILED": 3, + "USER_IN_TOO_MANY_CHANNELS": 4, + "RATE_LIMIT_EXCEEDED": 5, + "CHANNEL_FULL": 6, + "CHANNEL_FULL_OVERFLOWED": 7, + "FAILED_TO_ADD_USER": 8, + "CHANNEL_TYPE_DISABLED": 9, + "PRIVATE_CHAT_CREATE_FAILED": 10, + "PRIVATE_CHAT_NO_PERMISSION": 11, + "PRIVATE_CHAT_CREATE_LOCK_FAILED": 12, + "PRIVATE_CHAT_KICKED": 13, +} + +func (x CMsgDOTAJoinChatChannelResponse_Result) Enum() *CMsgDOTAJoinChatChannelResponse_Result { + p := new(CMsgDOTAJoinChatChannelResponse_Result) + *p = x + return p +} +func (x CMsgDOTAJoinChatChannelResponse_Result) String() string { + return proto.EnumName(CMsgDOTAJoinChatChannelResponse_Result_name, int32(x)) +} +func (x *CMsgDOTAJoinChatChannelResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAJoinChatChannelResponse_Result_value, data, "CMsgDOTAJoinChatChannelResponse_Result") + if err != nil { + return err + } + *x = CMsgDOTAJoinChatChannelResponse_Result(value) + return nil +} +func (CMsgDOTAJoinChatChannelResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{107, 0} +} + +type CMsgDOTAGuildCreateResponse_EError int32 + +const ( + CMsgDOTAGuildCreateResponse_UNSPECIFIED CMsgDOTAGuildCreateResponse_EError = 0 + CMsgDOTAGuildCreateResponse_NAME_EMPTY CMsgDOTAGuildCreateResponse_EError = 1 + CMsgDOTAGuildCreateResponse_NAME_BAD_CHARACTERS CMsgDOTAGuildCreateResponse_EError = 2 + CMsgDOTAGuildCreateResponse_NAME_TOO_LONG CMsgDOTAGuildCreateResponse_EError = 3 + CMsgDOTAGuildCreateResponse_NAME_TAKEN CMsgDOTAGuildCreateResponse_EError = 4 + CMsgDOTAGuildCreateResponse_TAG_EMPTY CMsgDOTAGuildCreateResponse_EError = 5 + CMsgDOTAGuildCreateResponse_TAG_BAD_CHARACTERS CMsgDOTAGuildCreateResponse_EError = 6 + CMsgDOTAGuildCreateResponse_TAG_TOO_LONG CMsgDOTAGuildCreateResponse_EError = 7 + CMsgDOTAGuildCreateResponse_ACCOUNT_TOO_MANY_GUILDS CMsgDOTAGuildCreateResponse_EError = 8 + CMsgDOTAGuildCreateResponse_LOGO_UPLOAD_FAILED CMsgDOTAGuildCreateResponse_EError = 9 +) + +var CMsgDOTAGuildCreateResponse_EError_name = map[int32]string{ + 0: "UNSPECIFIED", + 1: "NAME_EMPTY", + 2: "NAME_BAD_CHARACTERS", + 3: "NAME_TOO_LONG", + 4: "NAME_TAKEN", + 5: "TAG_EMPTY", + 6: "TAG_BAD_CHARACTERS", + 7: "TAG_TOO_LONG", + 8: "ACCOUNT_TOO_MANY_GUILDS", + 9: "LOGO_UPLOAD_FAILED", +} +var CMsgDOTAGuildCreateResponse_EError_value = map[string]int32{ + "UNSPECIFIED": 0, + "NAME_EMPTY": 1, + "NAME_BAD_CHARACTERS": 2, + "NAME_TOO_LONG": 3, + "NAME_TAKEN": 4, + "TAG_EMPTY": 5, + "TAG_BAD_CHARACTERS": 6, + "TAG_TOO_LONG": 7, + "ACCOUNT_TOO_MANY_GUILDS": 8, + "LOGO_UPLOAD_FAILED": 9, +} + +func (x CMsgDOTAGuildCreateResponse_EError) Enum() *CMsgDOTAGuildCreateResponse_EError { + p := new(CMsgDOTAGuildCreateResponse_EError) + *p = x + return p +} +func (x CMsgDOTAGuildCreateResponse_EError) String() string { + return proto.EnumName(CMsgDOTAGuildCreateResponse_EError_name, int32(x)) +} +func (x *CMsgDOTAGuildCreateResponse_EError) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAGuildCreateResponse_EError_value, data, "CMsgDOTAGuildCreateResponse_EError") + if err != nil { + return err + } + *x = CMsgDOTAGuildCreateResponse_EError(value) + return nil +} +func (CMsgDOTAGuildCreateResponse_EError) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{123, 0} +} + +type CMsgDOTAGuildSetAccountRoleResponse_EResult int32 + +const ( + CMsgDOTAGuildSetAccountRoleResponse_SUCCESS CMsgDOTAGuildSetAccountRoleResponse_EResult = 0 + CMsgDOTAGuildSetAccountRoleResponse_ERROR_UNSPECIFIED CMsgDOTAGuildSetAccountRoleResponse_EResult = 1 + CMsgDOTAGuildSetAccountRoleResponse_ERROR_NO_PERMISSION CMsgDOTAGuildSetAccountRoleResponse_EResult = 2 + CMsgDOTAGuildSetAccountRoleResponse_ERROR_NO_OTHER_LEADER CMsgDOTAGuildSetAccountRoleResponse_EResult = 3 + CMsgDOTAGuildSetAccountRoleResponse_ERROR_ACCOUNT_TOO_MANY_GUILDS CMsgDOTAGuildSetAccountRoleResponse_EResult = 4 + CMsgDOTAGuildSetAccountRoleResponse_ERROR_GUILD_TOO_MANY_MEMBERS CMsgDOTAGuildSetAccountRoleResponse_EResult = 5 +) + +var CMsgDOTAGuildSetAccountRoleResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", + 3: "ERROR_NO_OTHER_LEADER", + 4: "ERROR_ACCOUNT_TOO_MANY_GUILDS", + 5: "ERROR_GUILD_TOO_MANY_MEMBERS", +} +var CMsgDOTAGuildSetAccountRoleResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, + "ERROR_NO_OTHER_LEADER": 3, + "ERROR_ACCOUNT_TOO_MANY_GUILDS": 4, + "ERROR_GUILD_TOO_MANY_MEMBERS": 5, +} + +func (x CMsgDOTAGuildSetAccountRoleResponse_EResult) Enum() *CMsgDOTAGuildSetAccountRoleResponse_EResult { + p := new(CMsgDOTAGuildSetAccountRoleResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAGuildSetAccountRoleResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAGuildSetAccountRoleResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAGuildSetAccountRoleResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAGuildSetAccountRoleResponse_EResult_value, data, "CMsgDOTAGuildSetAccountRoleResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAGuildSetAccountRoleResponse_EResult(value) + return nil +} +func (CMsgDOTAGuildSetAccountRoleResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{125, 0} +} + +type CMsgDOTAGuildInviteAccountResponse_EResult int32 + +const ( + CMsgDOTAGuildInviteAccountResponse_SUCCESS CMsgDOTAGuildInviteAccountResponse_EResult = 0 + CMsgDOTAGuildInviteAccountResponse_ERROR_UNSPECIFIED CMsgDOTAGuildInviteAccountResponse_EResult = 1 + CMsgDOTAGuildInviteAccountResponse_ERROR_NO_PERMISSION CMsgDOTAGuildInviteAccountResponse_EResult = 2 + CMsgDOTAGuildInviteAccountResponse_ERROR_ACCOUNT_ALREADY_INVITED CMsgDOTAGuildInviteAccountResponse_EResult = 3 + CMsgDOTAGuildInviteAccountResponse_ERROR_ACCOUNT_ALREADY_IN_GUILD CMsgDOTAGuildInviteAccountResponse_EResult = 4 + CMsgDOTAGuildInviteAccountResponse_ERROR_ACCOUNT_TOO_MANY_INVITES CMsgDOTAGuildInviteAccountResponse_EResult = 5 + CMsgDOTAGuildInviteAccountResponse_ERROR_GUILD_TOO_MANY_INVITES CMsgDOTAGuildInviteAccountResponse_EResult = 6 + CMsgDOTAGuildInviteAccountResponse_ERROR_ACCOUNT_TOO_MANY_GUILDS CMsgDOTAGuildInviteAccountResponse_EResult = 7 +) + +var CMsgDOTAGuildInviteAccountResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", + 3: "ERROR_ACCOUNT_ALREADY_INVITED", + 4: "ERROR_ACCOUNT_ALREADY_IN_GUILD", + 5: "ERROR_ACCOUNT_TOO_MANY_INVITES", + 6: "ERROR_GUILD_TOO_MANY_INVITES", + 7: "ERROR_ACCOUNT_TOO_MANY_GUILDS", +} +var CMsgDOTAGuildInviteAccountResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, + "ERROR_ACCOUNT_ALREADY_INVITED": 3, + "ERROR_ACCOUNT_ALREADY_IN_GUILD": 4, + "ERROR_ACCOUNT_TOO_MANY_INVITES": 5, + "ERROR_GUILD_TOO_MANY_INVITES": 6, + "ERROR_ACCOUNT_TOO_MANY_GUILDS": 7, +} + +func (x CMsgDOTAGuildInviteAccountResponse_EResult) Enum() *CMsgDOTAGuildInviteAccountResponse_EResult { + p := new(CMsgDOTAGuildInviteAccountResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAGuildInviteAccountResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAGuildInviteAccountResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAGuildInviteAccountResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAGuildInviteAccountResponse_EResult_value, data, "CMsgDOTAGuildInviteAccountResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAGuildInviteAccountResponse_EResult(value) + return nil +} +func (CMsgDOTAGuildInviteAccountResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{127, 0} +} + +type CMsgDOTAGuildCancelInviteResponse_EResult int32 + +const ( + CMsgDOTAGuildCancelInviteResponse_SUCCESS CMsgDOTAGuildCancelInviteResponse_EResult = 0 + CMsgDOTAGuildCancelInviteResponse_ERROR_UNSPECIFIED CMsgDOTAGuildCancelInviteResponse_EResult = 1 + CMsgDOTAGuildCancelInviteResponse_ERROR_NO_PERMISSION CMsgDOTAGuildCancelInviteResponse_EResult = 2 +) + +var CMsgDOTAGuildCancelInviteResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAGuildCancelInviteResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAGuildCancelInviteResponse_EResult) Enum() *CMsgDOTAGuildCancelInviteResponse_EResult { + p := new(CMsgDOTAGuildCancelInviteResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAGuildCancelInviteResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAGuildCancelInviteResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAGuildCancelInviteResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAGuildCancelInviteResponse_EResult_value, data, "CMsgDOTAGuildCancelInviteResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAGuildCancelInviteResponse_EResult(value) + return nil +} +func (CMsgDOTAGuildCancelInviteResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{129, 0} +} + +type CMsgDOTAGuildUpdateDetailsResponse_EResult int32 + +const ( + CMsgDOTAGuildUpdateDetailsResponse_SUCCESS CMsgDOTAGuildUpdateDetailsResponse_EResult = 0 + CMsgDOTAGuildUpdateDetailsResponse_ERROR_UNSPECIFIED CMsgDOTAGuildUpdateDetailsResponse_EResult = 1 + CMsgDOTAGuildUpdateDetailsResponse_ERROR_NO_PERMISSION CMsgDOTAGuildUpdateDetailsResponse_EResult = 2 +) + +var CMsgDOTAGuildUpdateDetailsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAGuildUpdateDetailsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAGuildUpdateDetailsResponse_EResult) Enum() *CMsgDOTAGuildUpdateDetailsResponse_EResult { + p := new(CMsgDOTAGuildUpdateDetailsResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAGuildUpdateDetailsResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAGuildUpdateDetailsResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAGuildUpdateDetailsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAGuildUpdateDetailsResponse_EResult_value, data, "CMsgDOTAGuildUpdateDetailsResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAGuildUpdateDetailsResponse_EResult(value) + return nil +} +func (CMsgDOTAGuildUpdateDetailsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{131, 0} +} + +type CMsgDOTAPartySetOpenGuildResponse_EResult int32 + +const ( + CMsgDOTAPartySetOpenGuildResponse_SUCCESS CMsgDOTAPartySetOpenGuildResponse_EResult = 0 + CMsgDOTAPartySetOpenGuildResponse_ERROR_UNSPECIFIED CMsgDOTAPartySetOpenGuildResponse_EResult = 1 +) + +var CMsgDOTAPartySetOpenGuildResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", +} +var CMsgDOTAPartySetOpenGuildResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, +} + +func (x CMsgDOTAPartySetOpenGuildResponse_EResult) Enum() *CMsgDOTAPartySetOpenGuildResponse_EResult { + p := new(CMsgDOTAPartySetOpenGuildResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAPartySetOpenGuildResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAPartySetOpenGuildResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAPartySetOpenGuildResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAPartySetOpenGuildResponse_EResult_value, data, "CMsgDOTAPartySetOpenGuildResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAPartySetOpenGuildResponse_EResult(value) + return nil +} +func (CMsgDOTAPartySetOpenGuildResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{137, 0} +} + +type CMsgDOTAJoinOpenGuildPartyResponse_EResult int32 + +const ( + CMsgDOTAJoinOpenGuildPartyResponse_SUCCESS CMsgDOTAJoinOpenGuildPartyResponse_EResult = 0 + CMsgDOTAJoinOpenGuildPartyResponse_ERROR_UNSPECIFIED CMsgDOTAJoinOpenGuildPartyResponse_EResult = 1 +) + +var CMsgDOTAJoinOpenGuildPartyResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", +} +var CMsgDOTAJoinOpenGuildPartyResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, +} + +func (x CMsgDOTAJoinOpenGuildPartyResponse_EResult) Enum() *CMsgDOTAJoinOpenGuildPartyResponse_EResult { + p := new(CMsgDOTAJoinOpenGuildPartyResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAJoinOpenGuildPartyResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAJoinOpenGuildPartyResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAJoinOpenGuildPartyResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAJoinOpenGuildPartyResponse_EResult_value, data, "CMsgDOTAJoinOpenGuildPartyResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAJoinOpenGuildPartyResponse_EResult(value) + return nil +} +func (CMsgDOTAJoinOpenGuildPartyResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{139, 0} +} + +type CMsgDOTAGuildEditLogoResponse_EResult int32 + +const ( + CMsgDOTAGuildEditLogoResponse_SUCCESS CMsgDOTAGuildEditLogoResponse_EResult = 0 + CMsgDOTAGuildEditLogoResponse_NO_PERMISSION CMsgDOTAGuildEditLogoResponse_EResult = 1 + CMsgDOTAGuildEditLogoResponse_LOGO_UPLOAD_FAILED CMsgDOTAGuildEditLogoResponse_EResult = 2 + CMsgDOTAGuildEditLogoResponse_UNSPECIFIED_ERROR CMsgDOTAGuildEditLogoResponse_EResult = 3 +) + +var CMsgDOTAGuildEditLogoResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "NO_PERMISSION", + 2: "LOGO_UPLOAD_FAILED", + 3: "UNSPECIFIED_ERROR", +} +var CMsgDOTAGuildEditLogoResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "NO_PERMISSION": 1, + "LOGO_UPLOAD_FAILED": 2, + "UNSPECIFIED_ERROR": 3, +} + +func (x CMsgDOTAGuildEditLogoResponse_EResult) Enum() *CMsgDOTAGuildEditLogoResponse_EResult { + p := new(CMsgDOTAGuildEditLogoResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAGuildEditLogoResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAGuildEditLogoResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAGuildEditLogoResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAGuildEditLogoResponse_EResult_value, data, "CMsgDOTAGuildEditLogoResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAGuildEditLogoResponse_EResult(value) + return nil +} +func (CMsgDOTAGuildEditLogoResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{145, 0} +} + +type CMsgWatchGameResponse_WatchGameResult int32 + +const ( + CMsgWatchGameResponse_PENDING CMsgWatchGameResponse_WatchGameResult = 0 + CMsgWatchGameResponse_READY CMsgWatchGameResponse_WatchGameResult = 1 + CMsgWatchGameResponse_GAMESERVERNOTFOUND CMsgWatchGameResponse_WatchGameResult = 2 + CMsgWatchGameResponse_UNAVAILABLE CMsgWatchGameResponse_WatchGameResult = 3 + CMsgWatchGameResponse_CANCELLED CMsgWatchGameResponse_WatchGameResult = 4 + CMsgWatchGameResponse_INCOMPATIBLEVERSION CMsgWatchGameResponse_WatchGameResult = 5 + CMsgWatchGameResponse_MISSINGLEAGUESUBSCRIPTION CMsgWatchGameResponse_WatchGameResult = 6 + CMsgWatchGameResponse_LOBBYNOTFOUND CMsgWatchGameResponse_WatchGameResult = 7 +) + +var CMsgWatchGameResponse_WatchGameResult_name = map[int32]string{ + 0: "PENDING", + 1: "READY", + 2: "GAMESERVERNOTFOUND", + 3: "UNAVAILABLE", + 4: "CANCELLED", + 5: "INCOMPATIBLEVERSION", + 6: "MISSINGLEAGUESUBSCRIPTION", + 7: "LOBBYNOTFOUND", +} +var CMsgWatchGameResponse_WatchGameResult_value = map[string]int32{ + "PENDING": 0, + "READY": 1, + "GAMESERVERNOTFOUND": 2, + "UNAVAILABLE": 3, + "CANCELLED": 4, + "INCOMPATIBLEVERSION": 5, + "MISSINGLEAGUESUBSCRIPTION": 6, + "LOBBYNOTFOUND": 7, +} + +func (x CMsgWatchGameResponse_WatchGameResult) Enum() *CMsgWatchGameResponse_WatchGameResult { + p := new(CMsgWatchGameResponse_WatchGameResult) + *p = x + return p +} +func (x CMsgWatchGameResponse_WatchGameResult) String() string { + return proto.EnumName(CMsgWatchGameResponse_WatchGameResult_name, int32(x)) +} +func (x *CMsgWatchGameResponse_WatchGameResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgWatchGameResponse_WatchGameResult_value, data, "CMsgWatchGameResponse_WatchGameResult") + if err != nil { + return err + } + *x = CMsgWatchGameResponse_WatchGameResult(value) + return nil +} +func (CMsgWatchGameResponse_WatchGameResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{157, 0} +} + +type CMsgDOTAFriendRecruitsResponse_EResult int32 + +const ( + CMsgDOTAFriendRecruitsResponse_SUCCESS CMsgDOTAFriendRecruitsResponse_EResult = 0 + CMsgDOTAFriendRecruitsResponse_ERROR_UNSPECIFIED CMsgDOTAFriendRecruitsResponse_EResult = 1 +) + +var CMsgDOTAFriendRecruitsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", +} +var CMsgDOTAFriendRecruitsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, +} + +func (x CMsgDOTAFriendRecruitsResponse_EResult) Enum() *CMsgDOTAFriendRecruitsResponse_EResult { + p := new(CMsgDOTAFriendRecruitsResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFriendRecruitsResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFriendRecruitsResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFriendRecruitsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFriendRecruitsResponse_EResult_value, data, "CMsgDOTAFriendRecruitsResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFriendRecruitsResponse_EResult(value) + return nil +} +func (CMsgDOTAFriendRecruitsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{222, 0} +} + +type CMsgDOTARedeemEventPrizeResponse_ResultCode int32 + +const ( + CMsgDOTARedeemEventPrizeResponse_Success CMsgDOTARedeemEventPrizeResponse_ResultCode = 0 + CMsgDOTARedeemEventPrizeResponse_ServerError CMsgDOTARedeemEventPrizeResponse_ResultCode = 1 + CMsgDOTARedeemEventPrizeResponse_InsufficientPoints CMsgDOTARedeemEventPrizeResponse_ResultCode = 2 + CMsgDOTARedeemEventPrizeResponse_PointsHeld CMsgDOTARedeemEventPrizeResponse_ResultCode = 3 +) + +var CMsgDOTARedeemEventPrizeResponse_ResultCode_name = map[int32]string{ + 0: "Success", + 1: "ServerError", + 2: "InsufficientPoints", + 3: "PointsHeld", +} +var CMsgDOTARedeemEventPrizeResponse_ResultCode_value = map[string]int32{ + "Success": 0, + "ServerError": 1, + "InsufficientPoints": 2, + "PointsHeld": 3, +} + +func (x CMsgDOTARedeemEventPrizeResponse_ResultCode) Enum() *CMsgDOTARedeemEventPrizeResponse_ResultCode { + p := new(CMsgDOTARedeemEventPrizeResponse_ResultCode) + *p = x + return p +} +func (x CMsgDOTARedeemEventPrizeResponse_ResultCode) String() string { + return proto.EnumName(CMsgDOTARedeemEventPrizeResponse_ResultCode_name, int32(x)) +} +func (x *CMsgDOTARedeemEventPrizeResponse_ResultCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTARedeemEventPrizeResponse_ResultCode_value, data, "CMsgDOTARedeemEventPrizeResponse_ResultCode") + if err != nil { + return err + } + *x = CMsgDOTARedeemEventPrizeResponse_ResultCode(value) + return nil +} +func (CMsgDOTARedeemEventPrizeResponse_ResultCode) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{245, 0} +} + +type CMsgGCNotificationsResponse_EResult int32 + +const ( + CMsgGCNotificationsResponse_SUCCESS CMsgGCNotificationsResponse_EResult = 0 + CMsgGCNotificationsResponse_ERROR_UNSPECIFIED CMsgGCNotificationsResponse_EResult = 1 +) + +var CMsgGCNotificationsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", +} +var CMsgGCNotificationsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, +} + +func (x CMsgGCNotificationsResponse_EResult) Enum() *CMsgGCNotificationsResponse_EResult { + p := new(CMsgGCNotificationsResponse_EResult) + *p = x + return p +} +func (x CMsgGCNotificationsResponse_EResult) String() string { + return proto.EnumName(CMsgGCNotificationsResponse_EResult_name, int32(x)) +} +func (x *CMsgGCNotificationsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgGCNotificationsResponse_EResult_value, data, "CMsgGCNotificationsResponse_EResult") + if err != nil { + return err + } + *x = CMsgGCNotificationsResponse_EResult(value) + return nil +} +func (CMsgGCNotificationsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{258, 0} +} + +type CMsgGCPlayerInfoSubmitResponse_EResult int32 + +const ( + CMsgGCPlayerInfoSubmitResponse_SUCCESS CMsgGCPlayerInfoSubmitResponse_EResult = 0 + CMsgGCPlayerInfoSubmitResponse_ERROR_UNSPECIFIED CMsgGCPlayerInfoSubmitResponse_EResult = 1 + CMsgGCPlayerInfoSubmitResponse_ERROR_INFO_LOCKED CMsgGCPlayerInfoSubmitResponse_EResult = 2 +) + +var CMsgGCPlayerInfoSubmitResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_INFO_LOCKED", +} +var CMsgGCPlayerInfoSubmitResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_INFO_LOCKED": 2, +} + +func (x CMsgGCPlayerInfoSubmitResponse_EResult) Enum() *CMsgGCPlayerInfoSubmitResponse_EResult { + p := new(CMsgGCPlayerInfoSubmitResponse_EResult) + *p = x + return p +} +func (x CMsgGCPlayerInfoSubmitResponse_EResult) String() string { + return proto.EnumName(CMsgGCPlayerInfoSubmitResponse_EResult_name, int32(x)) +} +func (x *CMsgGCPlayerInfoSubmitResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgGCPlayerInfoSubmitResponse_EResult_value, data, "CMsgGCPlayerInfoSubmitResponse_EResult") + if err != nil { + return err + } + *x = CMsgGCPlayerInfoSubmitResponse_EResult(value) + return nil +} +func (CMsgGCPlayerInfoSubmitResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{264, 0} +} + +type CMsgClientToGCCreateStaticRecipeResponse_EResponse int32 + +const ( + CMsgClientToGCCreateStaticRecipeResponse_eResponse_Success CMsgClientToGCCreateStaticRecipeResponse_EResponse = 0 + CMsgClientToGCCreateStaticRecipeResponse_eResponse_OfferingDisabled CMsgClientToGCCreateStaticRecipeResponse_EResponse = 1 + CMsgClientToGCCreateStaticRecipeResponse_eResponse_InvalidItems CMsgClientToGCCreateStaticRecipeResponse_EResponse = 2 + CMsgClientToGCCreateStaticRecipeResponse_eResponse_InternalError CMsgClientToGCCreateStaticRecipeResponse_EResponse = 3 + CMsgClientToGCCreateStaticRecipeResponse_eResponse_MissingLeague CMsgClientToGCCreateStaticRecipeResponse_EResponse = 4 +) + +var CMsgClientToGCCreateStaticRecipeResponse_EResponse_name = map[int32]string{ + 0: "eResponse_Success", + 1: "eResponse_OfferingDisabled", + 2: "eResponse_InvalidItems", + 3: "eResponse_InternalError", + 4: "eResponse_MissingLeague", +} +var CMsgClientToGCCreateStaticRecipeResponse_EResponse_value = map[string]int32{ + "eResponse_Success": 0, + "eResponse_OfferingDisabled": 1, + "eResponse_InvalidItems": 2, + "eResponse_InternalError": 3, + "eResponse_MissingLeague": 4, +} + +func (x CMsgClientToGCCreateStaticRecipeResponse_EResponse) Enum() *CMsgClientToGCCreateStaticRecipeResponse_EResponse { + p := new(CMsgClientToGCCreateStaticRecipeResponse_EResponse) + *p = x + return p +} +func (x CMsgClientToGCCreateStaticRecipeResponse_EResponse) String() string { + return proto.EnumName(CMsgClientToGCCreateStaticRecipeResponse_EResponse_name, int32(x)) +} +func (x *CMsgClientToGCCreateStaticRecipeResponse_EResponse) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgClientToGCCreateStaticRecipeResponse_EResponse_value, data, "CMsgClientToGCCreateStaticRecipeResponse_EResponse") + if err != nil { + return err + } + *x = CMsgClientToGCCreateStaticRecipeResponse_EResponse(value) + return nil +} +func (CMsgClientToGCCreateStaticRecipeResponse_EResponse) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{328, 0} +} + +type CMsgGCToClientPrivateChatResponse_Result int32 + +const ( + CMsgGCToClientPrivateChatResponse_SUCCESS CMsgGCToClientPrivateChatResponse_Result = 0 + CMsgGCToClientPrivateChatResponse_FAILURE_CREATION_LOCK CMsgGCToClientPrivateChatResponse_Result = 1 + CMsgGCToClientPrivateChatResponse_FAILURE_SQL_TRANSACTION CMsgGCToClientPrivateChatResponse_Result = 2 + CMsgGCToClientPrivateChatResponse_FAILURE_SDO_LOAD CMsgGCToClientPrivateChatResponse_Result = 3 + CMsgGCToClientPrivateChatResponse_FAILURE_NO_PERMISSION CMsgGCToClientPrivateChatResponse_Result = 4 + CMsgGCToClientPrivateChatResponse_FAILURE_ALREADY_MEMBER CMsgGCToClientPrivateChatResponse_Result = 5 + CMsgGCToClientPrivateChatResponse_FAILURE_NOT_A_MEMBER CMsgGCToClientPrivateChatResponse_Result = 7 + CMsgGCToClientPrivateChatResponse_FAILURE_NO_REMAINING_ADMINS CMsgGCToClientPrivateChatResponse_Result = 8 + CMsgGCToClientPrivateChatResponse_FAILURE_NO_ROOM CMsgGCToClientPrivateChatResponse_Result = 9 + CMsgGCToClientPrivateChatResponse_FAILURE_CREATION_RATE_LIMITED CMsgGCToClientPrivateChatResponse_Result = 10 + CMsgGCToClientPrivateChatResponse_FAILURE_UNKNOWN_CHANNEL_NAME CMsgGCToClientPrivateChatResponse_Result = 11 + CMsgGCToClientPrivateChatResponse_FAILURE_UNKNOWN_USER CMsgGCToClientPrivateChatResponse_Result = 12 + CMsgGCToClientPrivateChatResponse_FAILURE_UNKNOWN_ERROR CMsgGCToClientPrivateChatResponse_Result = 13 + CMsgGCToClientPrivateChatResponse_FAILURE_CANNOT_KICK_ADMIN CMsgGCToClientPrivateChatResponse_Result = 14 + CMsgGCToClientPrivateChatResponse_FAILURE_ALREADY_ADMIN CMsgGCToClientPrivateChatResponse_Result = 15 +) + +var CMsgGCToClientPrivateChatResponse_Result_name = map[int32]string{ + 0: "SUCCESS", + 1: "FAILURE_CREATION_LOCK", + 2: "FAILURE_SQL_TRANSACTION", + 3: "FAILURE_SDO_LOAD", + 4: "FAILURE_NO_PERMISSION", + 5: "FAILURE_ALREADY_MEMBER", + 7: "FAILURE_NOT_A_MEMBER", + 8: "FAILURE_NO_REMAINING_ADMINS", + 9: "FAILURE_NO_ROOM", + 10: "FAILURE_CREATION_RATE_LIMITED", + 11: "FAILURE_UNKNOWN_CHANNEL_NAME", + 12: "FAILURE_UNKNOWN_USER", + 13: "FAILURE_UNKNOWN_ERROR", + 14: "FAILURE_CANNOT_KICK_ADMIN", + 15: "FAILURE_ALREADY_ADMIN", +} +var CMsgGCToClientPrivateChatResponse_Result_value = map[string]int32{ + "SUCCESS": 0, + "FAILURE_CREATION_LOCK": 1, + "FAILURE_SQL_TRANSACTION": 2, + "FAILURE_SDO_LOAD": 3, + "FAILURE_NO_PERMISSION": 4, + "FAILURE_ALREADY_MEMBER": 5, + "FAILURE_NOT_A_MEMBER": 7, + "FAILURE_NO_REMAINING_ADMINS": 8, + "FAILURE_NO_ROOM": 9, + "FAILURE_CREATION_RATE_LIMITED": 10, + "FAILURE_UNKNOWN_CHANNEL_NAME": 11, + "FAILURE_UNKNOWN_USER": 12, + "FAILURE_UNKNOWN_ERROR": 13, + "FAILURE_CANNOT_KICK_ADMIN": 14, + "FAILURE_ALREADY_ADMIN": 15, +} + +func (x CMsgGCToClientPrivateChatResponse_Result) Enum() *CMsgGCToClientPrivateChatResponse_Result { + p := new(CMsgGCToClientPrivateChatResponse_Result) + *p = x + return p +} +func (x CMsgGCToClientPrivateChatResponse_Result) String() string { + return proto.EnumName(CMsgGCToClientPrivateChatResponse_Result_name, int32(x)) +} +func (x *CMsgGCToClientPrivateChatResponse_Result) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgGCToClientPrivateChatResponse_Result_value, data, "CMsgGCToClientPrivateChatResponse_Result") + if err != nil { + return err + } + *x = CMsgGCToClientPrivateChatResponse_Result(value) + return nil +} +func (CMsgGCToClientPrivateChatResponse_Result) EnumDescriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{342, 0} +} + +type CMsgStartFindingMatch struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Matchgroups *uint32 `protobuf:"varint,2,opt,name=matchgroups,def=4294967295" json:"matchgroups,omitempty"` + ClientVersion *uint32 `protobuf:"varint,3,opt,name=client_version" json:"client_version,omitempty"` + GameModes *uint32 `protobuf:"varint,4,opt,name=game_modes,def=4294967295" json:"game_modes,omitempty"` + BotDifficulty *DOTABotDifficulty `protobuf:"varint,5,opt,name=bot_difficulty,enum=DOTABotDifficulty,def=3" json:"bot_difficulty,omitempty"` + MatchType *MatchType `protobuf:"varint,6,opt,name=match_type,enum=MatchType,def=0" json:"match_type,omitempty"` + Matchlanguages *uint32 `protobuf:"varint,7,opt,name=matchlanguages,def=4294967295" json:"matchlanguages,omitempty"` + MapPreference *uint32 `protobuf:"varint,9,opt,name=map_preference" json:"map_preference,omitempty"` + TeamId *uint32 `protobuf:"varint,8,opt,name=team_id" json:"team_id,omitempty"` + GameLanguageEnum *MatchLanguages `protobuf:"varint,10,opt,name=game_language_enum,enum=MatchLanguages,def=0" json:"game_language_enum,omitempty"` + GameLanguageName *string `protobuf:"bytes,11,opt,name=game_language_name" json:"game_language_name,omitempty"` + PingData *CMsgClientPingData `protobuf:"bytes,12,opt,name=ping_data" json:"ping_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgStartFindingMatch) Reset() { *m = CMsgStartFindingMatch{} } +func (m *CMsgStartFindingMatch) String() string { return proto.CompactTextString(m) } +func (*CMsgStartFindingMatch) ProtoMessage() {} +func (*CMsgStartFindingMatch) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{0} } + +const Default_CMsgStartFindingMatch_Matchgroups uint32 = 4294967295 +const Default_CMsgStartFindingMatch_GameModes uint32 = 4294967295 +const Default_CMsgStartFindingMatch_BotDifficulty DOTABotDifficulty = DOTABotDifficulty_BOT_DIFFICULTY_HARD +const Default_CMsgStartFindingMatch_MatchType MatchType = MatchType_MATCH_TYPE_CASUAL +const Default_CMsgStartFindingMatch_Matchlanguages uint32 = 4294967295 +const Default_CMsgStartFindingMatch_GameLanguageEnum MatchLanguages = MatchLanguages_MATCH_LANGUAGE_INVALID + +func (m *CMsgStartFindingMatch) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *CMsgStartFindingMatch) GetMatchgroups() uint32 { + if m != nil && m.Matchgroups != nil { + return *m.Matchgroups + } + return Default_CMsgStartFindingMatch_Matchgroups +} + +func (m *CMsgStartFindingMatch) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgStartFindingMatch) GetGameModes() uint32 { + if m != nil && m.GameModes != nil { + return *m.GameModes + } + return Default_CMsgStartFindingMatch_GameModes +} + +func (m *CMsgStartFindingMatch) GetBotDifficulty() DOTABotDifficulty { + if m != nil && m.BotDifficulty != nil { + return *m.BotDifficulty + } + return Default_CMsgStartFindingMatch_BotDifficulty +} + +func (m *CMsgStartFindingMatch) GetMatchType() MatchType { + if m != nil && m.MatchType != nil { + return *m.MatchType + } + return Default_CMsgStartFindingMatch_MatchType +} + +func (m *CMsgStartFindingMatch) GetMatchlanguages() uint32 { + if m != nil && m.Matchlanguages != nil { + return *m.Matchlanguages + } + return Default_CMsgStartFindingMatch_Matchlanguages +} + +func (m *CMsgStartFindingMatch) GetMapPreference() uint32 { + if m != nil && m.MapPreference != nil { + return *m.MapPreference + } + return 0 +} + +func (m *CMsgStartFindingMatch) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgStartFindingMatch) GetGameLanguageEnum() MatchLanguages { + if m != nil && m.GameLanguageEnum != nil { + return *m.GameLanguageEnum + } + return Default_CMsgStartFindingMatch_GameLanguageEnum +} + +func (m *CMsgStartFindingMatch) GetGameLanguageName() string { + if m != nil && m.GameLanguageName != nil { + return *m.GameLanguageName + } + return "" +} + +func (m *CMsgStartFindingMatch) GetPingData() *CMsgClientPingData { + if m != nil { + return m.PingData + } + return nil +} + +type CMsgStopFindingMatch struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgStopFindingMatch) Reset() { *m = CMsgStopFindingMatch{} } +func (m *CMsgStopFindingMatch) String() string { return proto.CompactTextString(m) } +func (*CMsgStopFindingMatch) ProtoMessage() {} +func (*CMsgStopFindingMatch) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{1} } + +type CMsgReadyUp struct { + State *DOTALobbyReadyState `protobuf:"varint,1,opt,name=state,enum=DOTALobbyReadyState,def=0" json:"state,omitempty"` + ReadyUpKey *uint64 `protobuf:"fixed64,2,opt,name=ready_up_key" json:"ready_up_key,omitempty"` + HardwareSpecs *CDOTAClientHardwareSpecs `protobuf:"bytes,3,opt,name=hardware_specs" json:"hardware_specs,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgReadyUp) Reset() { *m = CMsgReadyUp{} } +func (m *CMsgReadyUp) String() string { return proto.CompactTextString(m) } +func (*CMsgReadyUp) ProtoMessage() {} +func (*CMsgReadyUp) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{2} } + +const Default_CMsgReadyUp_State DOTALobbyReadyState = DOTALobbyReadyState_DOTALobbyReadyState_UNDECLARED + +func (m *CMsgReadyUp) GetState() DOTALobbyReadyState { + if m != nil && m.State != nil { + return *m.State + } + return Default_CMsgReadyUp_State +} + +func (m *CMsgReadyUp) GetReadyUpKey() uint64 { + if m != nil && m.ReadyUpKey != nil { + return *m.ReadyUpKey + } + return 0 +} + +func (m *CMsgReadyUp) GetHardwareSpecs() *CDOTAClientHardwareSpecs { + if m != nil { + return m.HardwareSpecs + } + return nil +} + +type CMsgReadyUpStatus struct { + LobbyId *uint64 `protobuf:"fixed64,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + AcceptedIds []uint32 `protobuf:"varint,2,rep,name=accepted_ids" json:"accepted_ids,omitempty"` + DeclinedIds []uint32 `protobuf:"varint,3,rep,name=declined_ids" json:"declined_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgReadyUpStatus) Reset() { *m = CMsgReadyUpStatus{} } +func (m *CMsgReadyUpStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgReadyUpStatus) ProtoMessage() {} +func (*CMsgReadyUpStatus) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{3} } + +func (m *CMsgReadyUpStatus) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgReadyUpStatus) GetAcceptedIds() []uint32 { + if m != nil { + return m.AcceptedIds + } + return nil +} + +func (m *CMsgReadyUpStatus) GetDeclinedIds() []uint32 { + if m != nil { + return m.DeclinedIds + } + return nil +} + +type CSourceTVGameSmall struct { + ActivateTime *uint32 `protobuf:"varint,1,opt,name=activate_time" json:"activate_time,omitempty"` + DeactivateTime *uint32 `protobuf:"varint,2,opt,name=deactivate_time" json:"deactivate_time,omitempty"` + ServerSteamId *uint64 `protobuf:"varint,3,opt,name=server_steam_id" json:"server_steam_id,omitempty"` + LobbyId *uint64 `protobuf:"varint,4,opt,name=lobby_id" json:"lobby_id,omitempty"` + LeagueId *uint32 `protobuf:"varint,5,opt,name=league_id" json:"league_id,omitempty"` + LobbyType *uint32 `protobuf:"varint,6,opt,name=lobby_type" json:"lobby_type,omitempty"` + GameTime *int32 `protobuf:"varint,7,opt,name=game_time" json:"game_time,omitempty"` + Delay *uint32 `protobuf:"varint,8,opt,name=delay" json:"delay,omitempty"` + Spectators *uint32 `protobuf:"varint,9,opt,name=spectators" json:"spectators,omitempty"` + GameMode *uint32 `protobuf:"varint,10,opt,name=game_mode" json:"game_mode,omitempty"` + AverageMmr *uint32 `protobuf:"varint,11,opt,name=average_mmr" json:"average_mmr,omitempty"` + TeamNameRadiant *string `protobuf:"bytes,15,opt,name=team_name_radiant" json:"team_name_radiant,omitempty"` + TeamNameDire *string `protobuf:"bytes,16,opt,name=team_name_dire" json:"team_name_dire,omitempty"` + SortScore *uint32 `protobuf:"varint,17,opt,name=sort_score" json:"sort_score,omitempty"` + LastUpdateTime *float32 `protobuf:"fixed32,18,opt,name=last_update_time" json:"last_update_time,omitempty"` + RadiantLead *int32 `protobuf:"varint,19,opt,name=radiant_lead" json:"radiant_lead,omitempty"` + RadiantScore *uint32 `protobuf:"varint,20,opt,name=radiant_score" json:"radiant_score,omitempty"` + DireScore *uint32 `protobuf:"varint,21,opt,name=dire_score" json:"dire_score,omitempty"` + Players []*CSourceTVGameSmall_Player `protobuf:"bytes,22,rep,name=players" json:"players,omitempty"` + BuildingState *uint32 `protobuf:"fixed32,23,opt,name=building_state" json:"building_state,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSourceTVGameSmall) Reset() { *m = CSourceTVGameSmall{} } +func (m *CSourceTVGameSmall) String() string { return proto.CompactTextString(m) } +func (*CSourceTVGameSmall) ProtoMessage() {} +func (*CSourceTVGameSmall) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{4} } + +func (m *CSourceTVGameSmall) GetActivateTime() uint32 { + if m != nil && m.ActivateTime != nil { + return *m.ActivateTime + } + return 0 +} + +func (m *CSourceTVGameSmall) GetDeactivateTime() uint32 { + if m != nil && m.DeactivateTime != nil { + return *m.DeactivateTime + } + return 0 +} + +func (m *CSourceTVGameSmall) GetServerSteamId() uint64 { + if m != nil && m.ServerSteamId != nil { + return *m.ServerSteamId + } + return 0 +} + +func (m *CSourceTVGameSmall) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CSourceTVGameSmall) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CSourceTVGameSmall) GetLobbyType() uint32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CSourceTVGameSmall) GetGameTime() int32 { + if m != nil && m.GameTime != nil { + return *m.GameTime + } + return 0 +} + +func (m *CSourceTVGameSmall) GetDelay() uint32 { + if m != nil && m.Delay != nil { + return *m.Delay + } + return 0 +} + +func (m *CSourceTVGameSmall) GetSpectators() uint32 { + if m != nil && m.Spectators != nil { + return *m.Spectators + } + return 0 +} + +func (m *CSourceTVGameSmall) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CSourceTVGameSmall) GetAverageMmr() uint32 { + if m != nil && m.AverageMmr != nil { + return *m.AverageMmr + } + return 0 +} + +func (m *CSourceTVGameSmall) GetTeamNameRadiant() string { + if m != nil && m.TeamNameRadiant != nil { + return *m.TeamNameRadiant + } + return "" +} + +func (m *CSourceTVGameSmall) GetTeamNameDire() string { + if m != nil && m.TeamNameDire != nil { + return *m.TeamNameDire + } + return "" +} + +func (m *CSourceTVGameSmall) GetSortScore() uint32 { + if m != nil && m.SortScore != nil { + return *m.SortScore + } + return 0 +} + +func (m *CSourceTVGameSmall) GetLastUpdateTime() float32 { + if m != nil && m.LastUpdateTime != nil { + return *m.LastUpdateTime + } + return 0 +} + +func (m *CSourceTVGameSmall) GetRadiantLead() int32 { + if m != nil && m.RadiantLead != nil { + return *m.RadiantLead + } + return 0 +} + +func (m *CSourceTVGameSmall) GetRadiantScore() uint32 { + if m != nil && m.RadiantScore != nil { + return *m.RadiantScore + } + return 0 +} + +func (m *CSourceTVGameSmall) GetDireScore() uint32 { + if m != nil && m.DireScore != nil { + return *m.DireScore + } + return 0 +} + +func (m *CSourceTVGameSmall) GetPlayers() []*CSourceTVGameSmall_Player { + if m != nil { + return m.Players + } + return nil +} + +func (m *CSourceTVGameSmall) GetBuildingState() uint32 { + if m != nil && m.BuildingState != nil { + return *m.BuildingState + } + return 0 +} + +type CSourceTVGameSmall_Player struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + HeroId *uint32 `protobuf:"varint,2,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSourceTVGameSmall_Player) Reset() { *m = CSourceTVGameSmall_Player{} } +func (m *CSourceTVGameSmall_Player) String() string { return proto.CompactTextString(m) } +func (*CSourceTVGameSmall_Player) ProtoMessage() {} +func (*CSourceTVGameSmall_Player) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{4, 0} } + +func (m *CSourceTVGameSmall_Player) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSourceTVGameSmall_Player) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgClientToGCFindTopSourceTVGames struct { + SearchKey *string `protobuf:"bytes,1,opt,name=search_key" json:"search_key,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + StartGame *uint32 `protobuf:"varint,4,opt,name=start_game" json:"start_game,omitempty"` + GameListIndex *uint32 `protobuf:"varint,5,opt,name=game_list_index" json:"game_list_index,omitempty"` + LobbyIds []uint64 `protobuf:"varint,6,rep,name=lobby_ids" json:"lobby_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCFindTopSourceTVGames) Reset() { *m = CMsgClientToGCFindTopSourceTVGames{} } +func (m *CMsgClientToGCFindTopSourceTVGames) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCFindTopSourceTVGames) ProtoMessage() {} +func (*CMsgClientToGCFindTopSourceTVGames) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{5} +} + +func (m *CMsgClientToGCFindTopSourceTVGames) GetSearchKey() string { + if m != nil && m.SearchKey != nil { + return *m.SearchKey + } + return "" +} + +func (m *CMsgClientToGCFindTopSourceTVGames) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgClientToGCFindTopSourceTVGames) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgClientToGCFindTopSourceTVGames) GetStartGame() uint32 { + if m != nil && m.StartGame != nil { + return *m.StartGame + } + return 0 +} + +func (m *CMsgClientToGCFindTopSourceTVGames) GetGameListIndex() uint32 { + if m != nil && m.GameListIndex != nil { + return *m.GameListIndex + } + return 0 +} + +func (m *CMsgClientToGCFindTopSourceTVGames) GetLobbyIds() []uint64 { + if m != nil { + return m.LobbyIds + } + return nil +} + +type CMsgGCToClientFindTopSourceTVGamesResponse struct { + SearchKey *string `protobuf:"bytes,1,opt,name=search_key" json:"search_key,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + StartGame *uint32 `protobuf:"varint,4,opt,name=start_game" json:"start_game,omitempty"` + NumGames *uint32 `protobuf:"varint,5,opt,name=num_games" json:"num_games,omitempty"` + GameListIndex *uint32 `protobuf:"varint,6,opt,name=game_list_index" json:"game_list_index,omitempty"` + GameList []*CSourceTVGameSmall `protobuf:"bytes,7,rep,name=game_list" json:"game_list,omitempty"` + SpecificGames *bool `protobuf:"varint,8,opt,name=specific_games" json:"specific_games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) Reset() { + *m = CMsgGCToClientFindTopSourceTVGamesResponse{} +} +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientFindTopSourceTVGamesResponse) ProtoMessage() {} +func (*CMsgGCToClientFindTopSourceTVGamesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{6} +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetSearchKey() string { + if m != nil && m.SearchKey != nil { + return *m.SearchKey + } + return "" +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetStartGame() uint32 { + if m != nil && m.StartGame != nil { + return *m.StartGame + } + return 0 +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetNumGames() uint32 { + if m != nil && m.NumGames != nil { + return *m.NumGames + } + return 0 +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetGameListIndex() uint32 { + if m != nil && m.GameListIndex != nil { + return *m.GameListIndex + } + return 0 +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetGameList() []*CSourceTVGameSmall { + if m != nil { + return m.GameList + } + return nil +} + +func (m *CMsgGCToClientFindTopSourceTVGamesResponse) GetSpecificGames() bool { + if m != nil && m.SpecificGames != nil { + return *m.SpecificGames + } + return false +} + +type CMsgClientToGCTopMatchesRequest struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + PlayerAccountId *uint32 `protobuf:"varint,2,opt,name=player_account_id" json:"player_account_id,omitempty"` + TeamId *uint32 `protobuf:"varint,3,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCTopMatchesRequest) Reset() { *m = CMsgClientToGCTopMatchesRequest{} } +func (m *CMsgClientToGCTopMatchesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCTopMatchesRequest) ProtoMessage() {} +func (*CMsgClientToGCTopMatchesRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{7} } + +func (m *CMsgClientToGCTopMatchesRequest) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgClientToGCTopMatchesRequest) GetPlayerAccountId() uint32 { + if m != nil && m.PlayerAccountId != nil { + return *m.PlayerAccountId + } + return 0 +} + +func (m *CMsgClientToGCTopMatchesRequest) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgClientToGCTopLeagueMatchesRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCTopLeagueMatchesRequest) Reset() { *m = CMsgClientToGCTopLeagueMatchesRequest{} } +func (m *CMsgClientToGCTopLeagueMatchesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCTopLeagueMatchesRequest) ProtoMessage() {} +func (*CMsgClientToGCTopLeagueMatchesRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{8} +} + +type CMsgClientToGCTopFriendMatchesRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCTopFriendMatchesRequest) Reset() { *m = CMsgClientToGCTopFriendMatchesRequest{} } +func (m *CMsgClientToGCTopFriendMatchesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCTopFriendMatchesRequest) ProtoMessage() {} +func (*CMsgClientToGCTopFriendMatchesRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{9} +} + +type CMsgClientToGCMatchesMinimalRequest struct { + MatchIds []uint64 `protobuf:"varint,1,rep,name=match_ids" json:"match_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCMatchesMinimalRequest) Reset() { *m = CMsgClientToGCMatchesMinimalRequest{} } +func (m *CMsgClientToGCMatchesMinimalRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCMatchesMinimalRequest) ProtoMessage() {} +func (*CMsgClientToGCMatchesMinimalRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{10} +} + +func (m *CMsgClientToGCMatchesMinimalRequest) GetMatchIds() []uint64 { + if m != nil { + return m.MatchIds + } + return nil +} + +type CMsgClientToGCMatchesMinimalResponse struct { + Matches []*CMsgDOTAMatchMinimal `protobuf:"bytes,1,rep,name=matches" json:"matches,omitempty"` + LastMatch *bool `protobuf:"varint,2,opt,name=last_match" json:"last_match,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCMatchesMinimalResponse) Reset() { *m = CMsgClientToGCMatchesMinimalResponse{} } +func (m *CMsgClientToGCMatchesMinimalResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCMatchesMinimalResponse) ProtoMessage() {} +func (*CMsgClientToGCMatchesMinimalResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{11} +} + +func (m *CMsgClientToGCMatchesMinimalResponse) GetMatches() []*CMsgDOTAMatchMinimal { + if m != nil { + return m.Matches + } + return nil +} + +func (m *CMsgClientToGCMatchesMinimalResponse) GetLastMatch() bool { + if m != nil && m.LastMatch != nil { + return *m.LastMatch + } + return false +} + +type CMsgGCToClientTopLeagueMatchesResponse struct { + Matches []*CMsgDOTAMatchMinimal `protobuf:"bytes,2,rep,name=matches" json:"matches,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientTopLeagueMatchesResponse) Reset() { + *m = CMsgGCToClientTopLeagueMatchesResponse{} +} +func (m *CMsgGCToClientTopLeagueMatchesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientTopLeagueMatchesResponse) ProtoMessage() {} +func (*CMsgGCToClientTopLeagueMatchesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{12} +} + +func (m *CMsgGCToClientTopLeagueMatchesResponse) GetMatches() []*CMsgDOTAMatchMinimal { + if m != nil { + return m.Matches + } + return nil +} + +type CMsgGCToClientTopFriendMatchesResponse struct { + Matches []*CMsgDOTAMatchMinimal `protobuf:"bytes,1,rep,name=matches" json:"matches,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientTopFriendMatchesResponse) Reset() { + *m = CMsgGCToClientTopFriendMatchesResponse{} +} +func (m *CMsgGCToClientTopFriendMatchesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientTopFriendMatchesResponse) ProtoMessage() {} +func (*CMsgGCToClientTopFriendMatchesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{13} +} + +func (m *CMsgGCToClientTopFriendMatchesResponse) GetMatches() []*CMsgDOTAMatchMinimal { + if m != nil { + return m.Matches + } + return nil +} + +type CMsgClientToGCFindTopMatches struct { + StartGame *uint32 `protobuf:"varint,1,opt,name=start_game" json:"start_game,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + FriendId *uint32 `protobuf:"varint,4,opt,name=friend_id" json:"friend_id,omitempty"` + FriendList *bool `protobuf:"varint,5,opt,name=friend_list" json:"friend_list,omitempty"` + LeagueList *bool `protobuf:"varint,6,opt,name=league_list" json:"league_list,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCFindTopMatches) Reset() { *m = CMsgClientToGCFindTopMatches{} } +func (m *CMsgClientToGCFindTopMatches) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCFindTopMatches) ProtoMessage() {} +func (*CMsgClientToGCFindTopMatches) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{14} } + +func (m *CMsgClientToGCFindTopMatches) GetStartGame() uint32 { + if m != nil && m.StartGame != nil { + return *m.StartGame + } + return 0 +} + +func (m *CMsgClientToGCFindTopMatches) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgClientToGCFindTopMatches) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgClientToGCFindTopMatches) GetFriendId() uint32 { + if m != nil && m.FriendId != nil { + return *m.FriendId + } + return 0 +} + +func (m *CMsgClientToGCFindTopMatches) GetFriendList() bool { + if m != nil && m.FriendList != nil { + return *m.FriendList + } + return false +} + +func (m *CMsgClientToGCFindTopMatches) GetLeagueList() bool { + if m != nil && m.LeagueList != nil { + return *m.LeagueList + } + return false +} + +type CMsgGCToClientFindTopLeagueMatchesResponse struct { + StartGame *uint32 `protobuf:"varint,1,opt,name=start_game" json:"start_game,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + MatchIds []uint32 `protobuf:"varint,4,rep,name=match_ids" json:"match_ids,omitempty"` + Matches []*CMsgDOTAMatch `protobuf:"bytes,5,rep,name=matches" json:"matches,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientFindTopLeagueMatchesResponse) Reset() { + *m = CMsgGCToClientFindTopLeagueMatchesResponse{} +} +func (m *CMsgGCToClientFindTopLeagueMatchesResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientFindTopLeagueMatchesResponse) ProtoMessage() {} +func (*CMsgGCToClientFindTopLeagueMatchesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{15} +} + +func (m *CMsgGCToClientFindTopLeagueMatchesResponse) GetStartGame() uint32 { + if m != nil && m.StartGame != nil { + return *m.StartGame + } + return 0 +} + +func (m *CMsgGCToClientFindTopLeagueMatchesResponse) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgGCToClientFindTopLeagueMatchesResponse) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgGCToClientFindTopLeagueMatchesResponse) GetMatchIds() []uint32 { + if m != nil { + return m.MatchIds + } + return nil +} + +func (m *CMsgGCToClientFindTopLeagueMatchesResponse) GetMatches() []*CMsgDOTAMatch { + if m != nil { + return m.Matches + } + return nil +} + +type CMsgSpectateFriendGame struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSpectateFriendGame) Reset() { *m = CMsgSpectateFriendGame{} } +func (m *CMsgSpectateFriendGame) String() string { return proto.CompactTextString(m) } +func (*CMsgSpectateFriendGame) ProtoMessage() {} +func (*CMsgSpectateFriendGame) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{16} } + +func (m *CMsgSpectateFriendGame) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CMsgSpectateFriendGameResponse struct { + ServerSteamid *uint64 `protobuf:"fixed64,4,opt,name=server_steamid" json:"server_steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSpectateFriendGameResponse) Reset() { *m = CMsgSpectateFriendGameResponse{} } +func (m *CMsgSpectateFriendGameResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgSpectateFriendGameResponse) ProtoMessage() {} +func (*CMsgSpectateFriendGameResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{17} } + +func (m *CMsgSpectateFriendGameResponse) GetServerSteamid() uint64 { + if m != nil && m.ServerSteamid != nil { + return *m.ServerSteamid + } + return 0 +} + +type CMsgAbandonCurrentGame struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAbandonCurrentGame) Reset() { *m = CMsgAbandonCurrentGame{} } +func (m *CMsgAbandonCurrentGame) String() string { return proto.CompactTextString(m) } +func (*CMsgAbandonCurrentGame) ProtoMessage() {} +func (*CMsgAbandonCurrentGame) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{18} } + +type CMsgClientSuspended struct { + TimeEnd *uint32 `protobuf:"varint,1,opt,name=time_end" json:"time_end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSuspended) Reset() { *m = CMsgClientSuspended{} } +func (m *CMsgClientSuspended) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSuspended) ProtoMessage() {} +func (*CMsgClientSuspended) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{19} } + +func (m *CMsgClientSuspended) GetTimeEnd() uint32 { + if m != nil && m.TimeEnd != nil { + return *m.TimeEnd + } + return 0 +} + +type CMsgPracticeLobbySetDetails struct { + LobbyId *uint64 `protobuf:"varint,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + GameName *string `protobuf:"bytes,2,opt,name=game_name" json:"game_name,omitempty"` + TeamDetails []*CLobbyTeamDetails `protobuf:"bytes,3,rep,name=team_details" json:"team_details,omitempty"` + ServerRegion *uint32 `protobuf:"varint,4,opt,name=server_region" json:"server_region,omitempty"` + GameMode *uint32 `protobuf:"varint,5,opt,name=game_mode" json:"game_mode,omitempty"` + CmPick *DOTA_CM_PICK `protobuf:"varint,6,opt,name=cm_pick,enum=DOTA_CM_PICK,def=0" json:"cm_pick,omitempty"` + BotDifficulty *DOTABotDifficulty `protobuf:"varint,9,opt,name=bot_difficulty,enum=DOTABotDifficulty,def=2" json:"bot_difficulty,omitempty"` + AllowCheats *bool `protobuf:"varint,10,opt,name=allow_cheats" json:"allow_cheats,omitempty"` + FillWithBots *bool `protobuf:"varint,11,opt,name=fill_with_bots" json:"fill_with_bots,omitempty"` + IntroMode *bool `protobuf:"varint,12,opt,name=intro_mode" json:"intro_mode,omitempty"` + AllowSpectating *bool `protobuf:"varint,13,opt,name=allow_spectating" json:"allow_spectating,omitempty"` + GameVersion *DOTAGameVersion `protobuf:"varint,14,opt,name=game_version,enum=DOTAGameVersion,def=0" json:"game_version,omitempty"` + PassKey *string `protobuf:"bytes,15,opt,name=pass_key" json:"pass_key,omitempty"` + Leagueid *uint32 `protobuf:"varint,16,opt,name=leagueid" json:"leagueid,omitempty"` + PenaltyLevelRadiant *uint32 `protobuf:"varint,17,opt,name=penalty_level_radiant" json:"penalty_level_radiant,omitempty"` + PenaltyLevelDire *uint32 `protobuf:"varint,18,opt,name=penalty_level_dire" json:"penalty_level_dire,omitempty"` + LoadGameId *uint32 `protobuf:"varint,19,opt,name=load_game_id" json:"load_game_id,omitempty"` + SeriesType *uint32 `protobuf:"varint,20,opt,name=series_type" json:"series_type,omitempty"` + RadiantSeriesWins *uint32 `protobuf:"varint,21,opt,name=radiant_series_wins" json:"radiant_series_wins,omitempty"` + DireSeriesWins *uint32 `protobuf:"varint,22,opt,name=dire_series_wins" json:"dire_series_wins,omitempty"` + Allchat *bool `protobuf:"varint,23,opt,name=allchat,def=0" json:"allchat,omitempty"` + DotaTvDelay *LobbyDotaTVDelay `protobuf:"varint,24,opt,name=dota_tv_delay,enum=LobbyDotaTVDelay,def=1" json:"dota_tv_delay,omitempty"` + Lan *bool `protobuf:"varint,25,opt,name=lan" json:"lan,omitempty"` + CustomGameMode *string `protobuf:"bytes,26,opt,name=custom_game_mode" json:"custom_game_mode,omitempty"` + CustomMapName *string `protobuf:"bytes,27,opt,name=custom_map_name" json:"custom_map_name,omitempty"` + CustomDifficulty *uint32 `protobuf:"varint,28,opt,name=custom_difficulty" json:"custom_difficulty,omitempty"` + CustomGameId *uint64 `protobuf:"varint,29,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + CustomMinPlayers *uint32 `protobuf:"varint,30,opt,name=custom_min_players" json:"custom_min_players,omitempty"` + CustomMaxPlayers *uint32 `protobuf:"varint,31,opt,name=custom_max_players" json:"custom_max_players,omitempty"` + LanHostPingToServerRegion *uint32 `protobuf:"varint,32,opt,name=lan_host_ping_to_server_region" json:"lan_host_ping_to_server_region,omitempty"` + Visibility *DOTALobbyVisibility `protobuf:"varint,33,opt,name=visibility,enum=DOTALobbyVisibility,def=0" json:"visibility,omitempty"` + CustomGameCrc *uint64 `protobuf:"fixed64,34,opt,name=custom_game_crc" json:"custom_game_crc,omitempty"` + LeagueSeriesId *uint32 `protobuf:"varint,35,opt,name=league_series_id" json:"league_series_id,omitempty"` + LeagueGameId *uint32 `protobuf:"varint,36,opt,name=league_game_id" json:"league_game_id,omitempty"` + CustomGameTimestamp *uint32 `protobuf:"fixed32,37,opt,name=custom_game_timestamp" json:"custom_game_timestamp,omitempty"` + PreviousMatchOverride *uint64 `protobuf:"varint,38,opt,name=previous_match_override" json:"previous_match_override,omitempty"` + LeagueSelectionPriorityTeam *uint32 `protobuf:"varint,39,opt,name=league_selection_priority_team" json:"league_selection_priority_team,omitempty"` + LeagueSelectionPriorityChoice *SelectionPriorityType `protobuf:"varint,40,opt,name=league_selection_priority_choice,enum=SelectionPriorityType,def=0" json:"league_selection_priority_choice,omitempty"` + LeagueNonSelectionPriorityChoice *SelectionPriorityType `protobuf:"varint,41,opt,name=league_non_selection_priority_choice,enum=SelectionPriorityType,def=0" json:"league_non_selection_priority_choice,omitempty"` + PauseSetting *LobbyDotaPauseSetting `protobuf:"varint,42,opt,name=pause_setting,enum=LobbyDotaPauseSetting,def=0" json:"pause_setting,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbySetDetails) Reset() { *m = CMsgPracticeLobbySetDetails{} } +func (m *CMsgPracticeLobbySetDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbySetDetails) ProtoMessage() {} +func (*CMsgPracticeLobbySetDetails) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{20} } + +const Default_CMsgPracticeLobbySetDetails_CmPick DOTA_CM_PICK = DOTA_CM_PICK_DOTA_CM_RANDOM +const Default_CMsgPracticeLobbySetDetails_BotDifficulty DOTABotDifficulty = DOTABotDifficulty_BOT_DIFFICULTY_MEDIUM +const Default_CMsgPracticeLobbySetDetails_GameVersion DOTAGameVersion = DOTAGameVersion_GAME_VERSION_CURRENT +const Default_CMsgPracticeLobbySetDetails_Allchat bool = false +const Default_CMsgPracticeLobbySetDetails_DotaTvDelay LobbyDotaTVDelay = LobbyDotaTVDelay_LobbyDotaTV_120 +const Default_CMsgPracticeLobbySetDetails_Visibility DOTALobbyVisibility = DOTALobbyVisibility_DOTALobbyVisibility_Public +const Default_CMsgPracticeLobbySetDetails_LeagueSelectionPriorityChoice SelectionPriorityType = SelectionPriorityType_UNDEFINED +const Default_CMsgPracticeLobbySetDetails_LeagueNonSelectionPriorityChoice SelectionPriorityType = SelectionPriorityType_UNDEFINED +const Default_CMsgPracticeLobbySetDetails_PauseSetting LobbyDotaPauseSetting = LobbyDotaPauseSetting_LobbyDotaPauseSetting_Unlimited + +func (m *CMsgPracticeLobbySetDetails) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetGameName() string { + if m != nil && m.GameName != nil { + return *m.GameName + } + return "" +} + +func (m *CMsgPracticeLobbySetDetails) GetTeamDetails() []*CLobbyTeamDetails { + if m != nil { + return m.TeamDetails + } + return nil +} + +func (m *CMsgPracticeLobbySetDetails) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetCmPick() DOTA_CM_PICK { + if m != nil && m.CmPick != nil { + return *m.CmPick + } + return Default_CMsgPracticeLobbySetDetails_CmPick +} + +func (m *CMsgPracticeLobbySetDetails) GetBotDifficulty() DOTABotDifficulty { + if m != nil && m.BotDifficulty != nil { + return *m.BotDifficulty + } + return Default_CMsgPracticeLobbySetDetails_BotDifficulty +} + +func (m *CMsgPracticeLobbySetDetails) GetAllowCheats() bool { + if m != nil && m.AllowCheats != nil { + return *m.AllowCheats + } + return false +} + +func (m *CMsgPracticeLobbySetDetails) GetFillWithBots() bool { + if m != nil && m.FillWithBots != nil { + return *m.FillWithBots + } + return false +} + +func (m *CMsgPracticeLobbySetDetails) GetIntroMode() bool { + if m != nil && m.IntroMode != nil { + return *m.IntroMode + } + return false +} + +func (m *CMsgPracticeLobbySetDetails) GetAllowSpectating() bool { + if m != nil && m.AllowSpectating != nil { + return *m.AllowSpectating + } + return false +} + +func (m *CMsgPracticeLobbySetDetails) GetGameVersion() DOTAGameVersion { + if m != nil && m.GameVersion != nil { + return *m.GameVersion + } + return Default_CMsgPracticeLobbySetDetails_GameVersion +} + +func (m *CMsgPracticeLobbySetDetails) GetPassKey() string { + if m != nil && m.PassKey != nil { + return *m.PassKey + } + return "" +} + +func (m *CMsgPracticeLobbySetDetails) GetLeagueid() uint32 { + if m != nil && m.Leagueid != nil { + return *m.Leagueid + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetPenaltyLevelRadiant() uint32 { + if m != nil && m.PenaltyLevelRadiant != nil { + return *m.PenaltyLevelRadiant + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetPenaltyLevelDire() uint32 { + if m != nil && m.PenaltyLevelDire != nil { + return *m.PenaltyLevelDire + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetLoadGameId() uint32 { + if m != nil && m.LoadGameId != nil { + return *m.LoadGameId + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetRadiantSeriesWins() uint32 { + if m != nil && m.RadiantSeriesWins != nil { + return *m.RadiantSeriesWins + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetDireSeriesWins() uint32 { + if m != nil && m.DireSeriesWins != nil { + return *m.DireSeriesWins + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetAllchat() bool { + if m != nil && m.Allchat != nil { + return *m.Allchat + } + return Default_CMsgPracticeLobbySetDetails_Allchat +} + +func (m *CMsgPracticeLobbySetDetails) GetDotaTvDelay() LobbyDotaTVDelay { + if m != nil && m.DotaTvDelay != nil { + return *m.DotaTvDelay + } + return Default_CMsgPracticeLobbySetDetails_DotaTvDelay +} + +func (m *CMsgPracticeLobbySetDetails) GetLan() bool { + if m != nil && m.Lan != nil { + return *m.Lan + } + return false +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomGameMode() string { + if m != nil && m.CustomGameMode != nil { + return *m.CustomGameMode + } + return "" +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomMapName() string { + if m != nil && m.CustomMapName != nil { + return *m.CustomMapName + } + return "" +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomDifficulty() uint32 { + if m != nil && m.CustomDifficulty != nil { + return *m.CustomDifficulty + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomMinPlayers() uint32 { + if m != nil && m.CustomMinPlayers != nil { + return *m.CustomMinPlayers + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomMaxPlayers() uint32 { + if m != nil && m.CustomMaxPlayers != nil { + return *m.CustomMaxPlayers + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetLanHostPingToServerRegion() uint32 { + if m != nil && m.LanHostPingToServerRegion != nil { + return *m.LanHostPingToServerRegion + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetVisibility() DOTALobbyVisibility { + if m != nil && m.Visibility != nil { + return *m.Visibility + } + return Default_CMsgPracticeLobbySetDetails_Visibility +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomGameCrc() uint64 { + if m != nil && m.CustomGameCrc != nil { + return *m.CustomGameCrc + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetLeagueSeriesId() uint32 { + if m != nil && m.LeagueSeriesId != nil { + return *m.LeagueSeriesId + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetLeagueGameId() uint32 { + if m != nil && m.LeagueGameId != nil { + return *m.LeagueGameId + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetCustomGameTimestamp() uint32 { + if m != nil && m.CustomGameTimestamp != nil { + return *m.CustomGameTimestamp + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetPreviousMatchOverride() uint64 { + if m != nil && m.PreviousMatchOverride != nil { + return *m.PreviousMatchOverride + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetLeagueSelectionPriorityTeam() uint32 { + if m != nil && m.LeagueSelectionPriorityTeam != nil { + return *m.LeagueSelectionPriorityTeam + } + return 0 +} + +func (m *CMsgPracticeLobbySetDetails) GetLeagueSelectionPriorityChoice() SelectionPriorityType { + if m != nil && m.LeagueSelectionPriorityChoice != nil { + return *m.LeagueSelectionPriorityChoice + } + return Default_CMsgPracticeLobbySetDetails_LeagueSelectionPriorityChoice +} + +func (m *CMsgPracticeLobbySetDetails) GetLeagueNonSelectionPriorityChoice() SelectionPriorityType { + if m != nil && m.LeagueNonSelectionPriorityChoice != nil { + return *m.LeagueNonSelectionPriorityChoice + } + return Default_CMsgPracticeLobbySetDetails_LeagueNonSelectionPriorityChoice +} + +func (m *CMsgPracticeLobbySetDetails) GetPauseSetting() LobbyDotaPauseSetting { + if m != nil && m.PauseSetting != nil { + return *m.PauseSetting + } + return Default_CMsgPracticeLobbySetDetails_PauseSetting +} + +type CMsgPracticeLobbyCreate struct { + SearchKey *string `protobuf:"bytes,1,opt,name=search_key" json:"search_key,omitempty"` + TournamentGame *bool `protobuf:"varint,2,opt,name=tournament_game" json:"tournament_game,omitempty"` + TournamentGameId *uint32 `protobuf:"varint,3,opt,name=tournament_game_id" json:"tournament_game_id,omitempty"` + TournamentId *uint32 `protobuf:"varint,4,opt,name=tournament_id" json:"tournament_id,omitempty"` + PassKey *string `protobuf:"bytes,5,opt,name=pass_key" json:"pass_key,omitempty"` + ClientVersion *uint32 `protobuf:"varint,6,opt,name=client_version" json:"client_version,omitempty"` + LobbyDetails *CMsgPracticeLobbySetDetails `protobuf:"bytes,7,opt,name=lobby_details" json:"lobby_details,omitempty"` + SaveGame *CMsgPracticeLobbyCreate_SaveGame `protobuf:"bytes,8,opt,name=save_game" json:"save_game,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyCreate) Reset() { *m = CMsgPracticeLobbyCreate{} } +func (m *CMsgPracticeLobbyCreate) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyCreate) ProtoMessage() {} +func (*CMsgPracticeLobbyCreate) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{21} } + +func (m *CMsgPracticeLobbyCreate) GetSearchKey() string { + if m != nil && m.SearchKey != nil { + return *m.SearchKey + } + return "" +} + +func (m *CMsgPracticeLobbyCreate) GetTournamentGame() bool { + if m != nil && m.TournamentGame != nil { + return *m.TournamentGame + } + return false +} + +func (m *CMsgPracticeLobbyCreate) GetTournamentGameId() uint32 { + if m != nil && m.TournamentGameId != nil { + return *m.TournamentGameId + } + return 0 +} + +func (m *CMsgPracticeLobbyCreate) GetTournamentId() uint32 { + if m != nil && m.TournamentId != nil { + return *m.TournamentId + } + return 0 +} + +func (m *CMsgPracticeLobbyCreate) GetPassKey() string { + if m != nil && m.PassKey != nil { + return *m.PassKey + } + return "" +} + +func (m *CMsgPracticeLobbyCreate) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgPracticeLobbyCreate) GetLobbyDetails() *CMsgPracticeLobbySetDetails { + if m != nil { + return m.LobbyDetails + } + return nil +} + +func (m *CMsgPracticeLobbyCreate) GetSaveGame() *CMsgPracticeLobbyCreate_SaveGame { + if m != nil { + return m.SaveGame + } + return nil +} + +type CMsgPracticeLobbyCreate_SaveGame struct { + Data []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"` + Version *int32 `protobuf:"varint,2,opt,name=version" json:"version,omitempty"` + SteamId *uint64 `protobuf:"fixed64,3,opt,name=steam_id" json:"steam_id,omitempty"` + Signature *uint64 `protobuf:"fixed64,4,opt,name=signature" json:"signature,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyCreate_SaveGame) Reset() { *m = CMsgPracticeLobbyCreate_SaveGame{} } +func (m *CMsgPracticeLobbyCreate_SaveGame) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyCreate_SaveGame) ProtoMessage() {} +func (*CMsgPracticeLobbyCreate_SaveGame) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{21, 0} +} + +func (m *CMsgPracticeLobbyCreate_SaveGame) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *CMsgPracticeLobbyCreate_SaveGame) GetVersion() int32 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgPracticeLobbyCreate_SaveGame) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgPracticeLobbyCreate_SaveGame) GetSignature() uint64 { + if m != nil && m.Signature != nil { + return *m.Signature + } + return 0 +} + +type CMsgPracticeLobbySetTeamSlot struct { + Team *DOTA_GC_TEAM `protobuf:"varint,1,opt,name=team,enum=DOTA_GC_TEAM,def=0" json:"team,omitempty"` + Slot *uint32 `protobuf:"varint,2,opt,name=slot" json:"slot,omitempty"` + BotDifficulty *DOTABotDifficulty `protobuf:"varint,3,opt,name=bot_difficulty,enum=DOTABotDifficulty,def=0" json:"bot_difficulty,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbySetTeamSlot) Reset() { *m = CMsgPracticeLobbySetTeamSlot{} } +func (m *CMsgPracticeLobbySetTeamSlot) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbySetTeamSlot) ProtoMessage() {} +func (*CMsgPracticeLobbySetTeamSlot) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{22} } + +const Default_CMsgPracticeLobbySetTeamSlot_Team DOTA_GC_TEAM = DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS +const Default_CMsgPracticeLobbySetTeamSlot_BotDifficulty DOTABotDifficulty = DOTABotDifficulty_BOT_DIFFICULTY_PASSIVE + +func (m *CMsgPracticeLobbySetTeamSlot) GetTeam() DOTA_GC_TEAM { + if m != nil && m.Team != nil { + return *m.Team + } + return Default_CMsgPracticeLobbySetTeamSlot_Team +} + +func (m *CMsgPracticeLobbySetTeamSlot) GetSlot() uint32 { + if m != nil && m.Slot != nil { + return *m.Slot + } + return 0 +} + +func (m *CMsgPracticeLobbySetTeamSlot) GetBotDifficulty() DOTABotDifficulty { + if m != nil && m.BotDifficulty != nil { + return *m.BotDifficulty + } + return Default_CMsgPracticeLobbySetTeamSlot_BotDifficulty +} + +type CMsgPracticeLobbySetCoach struct { + Team *DOTA_GC_TEAM `protobuf:"varint,1,opt,name=team,enum=DOTA_GC_TEAM,def=0" json:"team,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbySetCoach) Reset() { *m = CMsgPracticeLobbySetCoach{} } +func (m *CMsgPracticeLobbySetCoach) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbySetCoach) ProtoMessage() {} +func (*CMsgPracticeLobbySetCoach) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{23} } + +const Default_CMsgPracticeLobbySetCoach_Team DOTA_GC_TEAM = DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS + +func (m *CMsgPracticeLobbySetCoach) GetTeam() DOTA_GC_TEAM { + if m != nil && m.Team != nil { + return *m.Team + } + return Default_CMsgPracticeLobbySetCoach_Team +} + +type CMsgPracticeLobbyJoinBroadcastChannel struct { + Channel *uint32 `protobuf:"varint,1,opt,name=channel" json:"channel,omitempty"` + PreferredDescription *string `protobuf:"bytes,2,opt,name=preferred_description" json:"preferred_description,omitempty"` + PreferredCountryCode *string `protobuf:"bytes,3,opt,name=preferred_country_code" json:"preferred_country_code,omitempty"` + PreferredLanguageCode *string `protobuf:"bytes,4,opt,name=preferred_language_code" json:"preferred_language_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyJoinBroadcastChannel) Reset() { *m = CMsgPracticeLobbyJoinBroadcastChannel{} } +func (m *CMsgPracticeLobbyJoinBroadcastChannel) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyJoinBroadcastChannel) ProtoMessage() {} +func (*CMsgPracticeLobbyJoinBroadcastChannel) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{24} +} + +func (m *CMsgPracticeLobbyJoinBroadcastChannel) GetChannel() uint32 { + if m != nil && m.Channel != nil { + return *m.Channel + } + return 0 +} + +func (m *CMsgPracticeLobbyJoinBroadcastChannel) GetPreferredDescription() string { + if m != nil && m.PreferredDescription != nil { + return *m.PreferredDescription + } + return "" +} + +func (m *CMsgPracticeLobbyJoinBroadcastChannel) GetPreferredCountryCode() string { + if m != nil && m.PreferredCountryCode != nil { + return *m.PreferredCountryCode + } + return "" +} + +func (m *CMsgPracticeLobbyJoinBroadcastChannel) GetPreferredLanguageCode() string { + if m != nil && m.PreferredLanguageCode != nil { + return *m.PreferredLanguageCode + } + return "" +} + +type CMsgPracticeLobbyCloseBroadcastChannel struct { + Channel *uint32 `protobuf:"varint,1,opt,name=channel" json:"channel,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyCloseBroadcastChannel) Reset() { + *m = CMsgPracticeLobbyCloseBroadcastChannel{} +} +func (m *CMsgPracticeLobbyCloseBroadcastChannel) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyCloseBroadcastChannel) ProtoMessage() {} +func (*CMsgPracticeLobbyCloseBroadcastChannel) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{25} +} + +func (m *CMsgPracticeLobbyCloseBroadcastChannel) GetChannel() uint32 { + if m != nil && m.Channel != nil { + return *m.Channel + } + return 0 +} + +type CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus) Reset() { + *m = CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus{} +} +func (m *CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus) String() string { + return proto.CompactTextString(m) +} +func (*CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus) ProtoMessage() {} +func (*CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{26} +} + +type CMsgPracticeLobbyKick struct { + AccountId *uint32 `protobuf:"varint,3,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyKick) Reset() { *m = CMsgPracticeLobbyKick{} } +func (m *CMsgPracticeLobbyKick) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyKick) ProtoMessage() {} +func (*CMsgPracticeLobbyKick) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{27} } + +func (m *CMsgPracticeLobbyKick) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgPracticeLobbyKickFromTeam struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyKickFromTeam) Reset() { *m = CMsgPracticeLobbyKickFromTeam{} } +func (m *CMsgPracticeLobbyKickFromTeam) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyKickFromTeam) ProtoMessage() {} +func (*CMsgPracticeLobbyKickFromTeam) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{28} } + +func (m *CMsgPracticeLobbyKickFromTeam) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgPracticeLobbyLeave struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyLeave) Reset() { *m = CMsgPracticeLobbyLeave{} } +func (m *CMsgPracticeLobbyLeave) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyLeave) ProtoMessage() {} +func (*CMsgPracticeLobbyLeave) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{29} } + +type CMsgPracticeLobbyLaunch struct { + ClientVersion *uint32 `protobuf:"varint,5,opt,name=client_version" json:"client_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyLaunch) Reset() { *m = CMsgPracticeLobbyLaunch{} } +func (m *CMsgPracticeLobbyLaunch) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyLaunch) ProtoMessage() {} +func (*CMsgPracticeLobbyLaunch) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{30} } + +func (m *CMsgPracticeLobbyLaunch) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +type CMsgApplyTeamToPracticeLobby struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgApplyTeamToPracticeLobby) Reset() { *m = CMsgApplyTeamToPracticeLobby{} } +func (m *CMsgApplyTeamToPracticeLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgApplyTeamToPracticeLobby) ProtoMessage() {} +func (*CMsgApplyTeamToPracticeLobby) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{31} } + +func (m *CMsgApplyTeamToPracticeLobby) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgClearPracticeLobbyTeam struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClearPracticeLobbyTeam) Reset() { *m = CMsgClearPracticeLobbyTeam{} } +func (m *CMsgClearPracticeLobbyTeam) String() string { return proto.CompactTextString(m) } +func (*CMsgClearPracticeLobbyTeam) ProtoMessage() {} +func (*CMsgClearPracticeLobbyTeam) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{32} } + +type CMsgPracticeLobbyList struct { + TournamentGames *bool `protobuf:"varint,1,opt,name=tournament_games" json:"tournament_games,omitempty"` + PassKey *string `protobuf:"bytes,2,opt,name=pass_key" json:"pass_key,omitempty"` + Region *uint32 `protobuf:"varint,3,opt,name=region" json:"region,omitempty"` + GameMode *DOTA_GameMode `protobuf:"varint,4,opt,name=game_mode,enum=DOTA_GameMode,def=0" json:"game_mode,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyList) Reset() { *m = CMsgPracticeLobbyList{} } +func (m *CMsgPracticeLobbyList) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyList) ProtoMessage() {} +func (*CMsgPracticeLobbyList) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{33} } + +const Default_CMsgPracticeLobbyList_GameMode DOTA_GameMode = DOTA_GameMode_DOTA_GAMEMODE_NONE + +func (m *CMsgPracticeLobbyList) GetTournamentGames() bool { + if m != nil && m.TournamentGames != nil { + return *m.TournamentGames + } + return false +} + +func (m *CMsgPracticeLobbyList) GetPassKey() string { + if m != nil && m.PassKey != nil { + return *m.PassKey + } + return "" +} + +func (m *CMsgPracticeLobbyList) GetRegion() uint32 { + if m != nil && m.Region != nil { + return *m.Region + } + return 0 +} + +func (m *CMsgPracticeLobbyList) GetGameMode() DOTA_GameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return Default_CMsgPracticeLobbyList_GameMode +} + +type CMsgPracticeLobbyListResponseEntry struct { + Id *uint64 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"` + TournamentId *uint32 `protobuf:"varint,3,opt,name=tournament_id" json:"tournament_id,omitempty"` + TournamentGameId *uint32 `protobuf:"varint,4,opt,name=tournament_game_id" json:"tournament_game_id,omitempty"` + Members []*CMsgPracticeLobbyListResponseEntry_CLobbyMember `protobuf:"bytes,5,rep,name=members" json:"members,omitempty"` + RequiresPassKey *bool `protobuf:"varint,6,opt,name=requires_pass_key" json:"requires_pass_key,omitempty"` + LeaderAccountId *uint32 `protobuf:"varint,7,opt,name=leader_account_id" json:"leader_account_id,omitempty"` + GuildId *uint32 `protobuf:"varint,8,opt,name=guild_id" json:"guild_id,omitempty"` + GuildLogo *uint64 `protobuf:"varint,9,opt,name=guild_logo" json:"guild_logo,omitempty"` + Name *string `protobuf:"bytes,10,opt,name=name" json:"name,omitempty"` + CustomGameMode *string `protobuf:"bytes,11,opt,name=custom_game_mode" json:"custom_game_mode,omitempty"` + GameMode *DOTA_GameMode `protobuf:"varint,12,opt,name=game_mode,enum=DOTA_GameMode,def=0" json:"game_mode,omitempty"` + FriendPresent *bool `protobuf:"varint,13,opt,name=friend_present" json:"friend_present,omitempty"` + Players *uint32 `protobuf:"varint,14,opt,name=players" json:"players,omitempty"` + CustomMapName *string `protobuf:"bytes,15,opt,name=custom_map_name" json:"custom_map_name,omitempty"` + MaxPlayerCount *uint32 `protobuf:"varint,16,opt,name=max_player_count" json:"max_player_count,omitempty"` + ServerRegion *uint32 `protobuf:"varint,17,opt,name=server_region" json:"server_region,omitempty"` + LanHostPingToServerRegion *uint32 `protobuf:"varint,18,opt,name=lan_host_ping_to_server_region" json:"lan_host_ping_to_server_region,omitempty"` + LeagueId *uint32 `protobuf:"varint,19,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyListResponseEntry) Reset() { *m = CMsgPracticeLobbyListResponseEntry{} } +func (m *CMsgPracticeLobbyListResponseEntry) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyListResponseEntry) ProtoMessage() {} +func (*CMsgPracticeLobbyListResponseEntry) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{34} +} + +const Default_CMsgPracticeLobbyListResponseEntry_GameMode DOTA_GameMode = DOTA_GameMode_DOTA_GAMEMODE_NONE + +func (m *CMsgPracticeLobbyListResponseEntry) GetId() uint64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetTournamentId() uint32 { + if m != nil && m.TournamentId != nil { + return *m.TournamentId + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetTournamentGameId() uint32 { + if m != nil && m.TournamentGameId != nil { + return *m.TournamentGameId + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetMembers() []*CMsgPracticeLobbyListResponseEntry_CLobbyMember { + if m != nil { + return m.Members + } + return nil +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetRequiresPassKey() bool { + if m != nil && m.RequiresPassKey != nil { + return *m.RequiresPassKey + } + return false +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetLeaderAccountId() uint32 { + if m != nil && m.LeaderAccountId != nil { + return *m.LeaderAccountId + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetGuildLogo() uint64 { + if m != nil && m.GuildLogo != nil { + return *m.GuildLogo + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetCustomGameMode() string { + if m != nil && m.CustomGameMode != nil { + return *m.CustomGameMode + } + return "" +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetGameMode() DOTA_GameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return Default_CMsgPracticeLobbyListResponseEntry_GameMode +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetFriendPresent() bool { + if m != nil && m.FriendPresent != nil { + return *m.FriendPresent + } + return false +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetPlayers() uint32 { + if m != nil && m.Players != nil { + return *m.Players + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetCustomMapName() string { + if m != nil && m.CustomMapName != nil { + return *m.CustomMapName + } + return "" +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetMaxPlayerCount() uint32 { + if m != nil && m.MaxPlayerCount != nil { + return *m.MaxPlayerCount + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetLanHostPingToServerRegion() uint32 { + if m != nil && m.LanHostPingToServerRegion != nil { + return *m.LanHostPingToServerRegion + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CMsgPracticeLobbyListResponseEntry_CLobbyMember struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + PlayerName *string `protobuf:"bytes,2,opt,name=player_name" json:"player_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyListResponseEntry_CLobbyMember) Reset() { + *m = CMsgPracticeLobbyListResponseEntry_CLobbyMember{} +} +func (m *CMsgPracticeLobbyListResponseEntry_CLobbyMember) String() string { + return proto.CompactTextString(m) +} +func (*CMsgPracticeLobbyListResponseEntry_CLobbyMember) ProtoMessage() {} +func (*CMsgPracticeLobbyListResponseEntry_CLobbyMember) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{34, 0} +} + +func (m *CMsgPracticeLobbyListResponseEntry_CLobbyMember) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgPracticeLobbyListResponseEntry_CLobbyMember) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +type CMsgPracticeLobbyListResponse struct { + TournamentGames *bool `protobuf:"varint,1,opt,name=tournament_games" json:"tournament_games,omitempty"` + Lobbies []*CMsgPracticeLobbyListResponseEntry `protobuf:"bytes,2,rep,name=lobbies" json:"lobbies,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyListResponse) Reset() { *m = CMsgPracticeLobbyListResponse{} } +func (m *CMsgPracticeLobbyListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyListResponse) ProtoMessage() {} +func (*CMsgPracticeLobbyListResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{35} } + +func (m *CMsgPracticeLobbyListResponse) GetTournamentGames() bool { + if m != nil && m.TournamentGames != nil { + return *m.TournamentGames + } + return false +} + +func (m *CMsgPracticeLobbyListResponse) GetLobbies() []*CMsgPracticeLobbyListResponseEntry { + if m != nil { + return m.Lobbies + } + return nil +} + +type CMsgLobbyList struct { + ServerRegion *uint32 `protobuf:"varint,1,opt,name=server_region,def=0" json:"server_region,omitempty"` + GameMode *DOTA_GameMode `protobuf:"varint,2,opt,name=game_mode,enum=DOTA_GameMode,def=0" json:"game_mode,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLobbyList) Reset() { *m = CMsgLobbyList{} } +func (m *CMsgLobbyList) String() string { return proto.CompactTextString(m) } +func (*CMsgLobbyList) ProtoMessage() {} +func (*CMsgLobbyList) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{36} } + +const Default_CMsgLobbyList_ServerRegion uint32 = 0 +const Default_CMsgLobbyList_GameMode DOTA_GameMode = DOTA_GameMode_DOTA_GAMEMODE_NONE + +func (m *CMsgLobbyList) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return Default_CMsgLobbyList_ServerRegion +} + +func (m *CMsgLobbyList) GetGameMode() DOTA_GameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return Default_CMsgLobbyList_GameMode +} + +type CMsgLobbyListResponse struct { + Lobbies []*CMsgPracticeLobbyListResponseEntry `protobuf:"bytes,1,rep,name=lobbies" json:"lobbies,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLobbyListResponse) Reset() { *m = CMsgLobbyListResponse{} } +func (m *CMsgLobbyListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgLobbyListResponse) ProtoMessage() {} +func (*CMsgLobbyListResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{37} } + +func (m *CMsgLobbyListResponse) GetLobbies() []*CMsgPracticeLobbyListResponseEntry { + if m != nil { + return m.Lobbies + } + return nil +} + +type CMsgPracticeLobbyJoin struct { + LobbyId *uint64 `protobuf:"varint,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + ClientVersion *uint32 `protobuf:"varint,2,opt,name=client_version" json:"client_version,omitempty"` + PassKey *string `protobuf:"bytes,3,opt,name=pass_key" json:"pass_key,omitempty"` + CustomGameCrc *uint64 `protobuf:"fixed64,4,opt,name=custom_game_crc" json:"custom_game_crc,omitempty"` + CustomGameTimestamp *uint32 `protobuf:"fixed32,5,opt,name=custom_game_timestamp" json:"custom_game_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyJoin) Reset() { *m = CMsgPracticeLobbyJoin{} } +func (m *CMsgPracticeLobbyJoin) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyJoin) ProtoMessage() {} +func (*CMsgPracticeLobbyJoin) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{38} } + +func (m *CMsgPracticeLobbyJoin) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgPracticeLobbyJoin) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgPracticeLobbyJoin) GetPassKey() string { + if m != nil && m.PassKey != nil { + return *m.PassKey + } + return "" +} + +func (m *CMsgPracticeLobbyJoin) GetCustomGameCrc() uint64 { + if m != nil && m.CustomGameCrc != nil { + return *m.CustomGameCrc + } + return 0 +} + +func (m *CMsgPracticeLobbyJoin) GetCustomGameTimestamp() uint32 { + if m != nil && m.CustomGameTimestamp != nil { + return *m.CustomGameTimestamp + } + return 0 +} + +type CMsgPracticeLobbyJoinResponse struct { + Result *DOTAJoinLobbyResult `protobuf:"varint,1,opt,name=result,enum=DOTAJoinLobbyResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPracticeLobbyJoinResponse) Reset() { *m = CMsgPracticeLobbyJoinResponse{} } +func (m *CMsgPracticeLobbyJoinResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgPracticeLobbyJoinResponse) ProtoMessage() {} +func (*CMsgPracticeLobbyJoinResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{39} } + +const Default_CMsgPracticeLobbyJoinResponse_Result DOTAJoinLobbyResult = DOTAJoinLobbyResult_DOTA_JOIN_RESULT_SUCCESS + +func (m *CMsgPracticeLobbyJoinResponse) GetResult() DOTAJoinLobbyResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgPracticeLobbyJoinResponse_Result +} + +type CMsgFriendPracticeLobbyListRequest struct { + Friends []uint32 `protobuf:"varint,1,rep,name=friends" json:"friends,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFriendPracticeLobbyListRequest) Reset() { *m = CMsgFriendPracticeLobbyListRequest{} } +func (m *CMsgFriendPracticeLobbyListRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgFriendPracticeLobbyListRequest) ProtoMessage() {} +func (*CMsgFriendPracticeLobbyListRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{40} +} + +func (m *CMsgFriendPracticeLobbyListRequest) GetFriends() []uint32 { + if m != nil { + return m.Friends + } + return nil +} + +type CMsgFriendPracticeLobbyListResponse struct { + Lobbies []*CMsgPracticeLobbyListResponseEntry `protobuf:"bytes,1,rep,name=lobbies" json:"lobbies,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFriendPracticeLobbyListResponse) Reset() { *m = CMsgFriendPracticeLobbyListResponse{} } +func (m *CMsgFriendPracticeLobbyListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgFriendPracticeLobbyListResponse) ProtoMessage() {} +func (*CMsgFriendPracticeLobbyListResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{41} +} + +func (m *CMsgFriendPracticeLobbyListResponse) GetLobbies() []*CMsgPracticeLobbyListResponseEntry { + if m != nil { + return m.Lobbies + } + return nil +} + +type CMsgGuildmatePracticeLobbyListRequest struct { + Guilds []uint32 `protobuf:"varint,1,rep,name=guilds" json:"guilds,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGuildmatePracticeLobbyListRequest) Reset() { *m = CMsgGuildmatePracticeLobbyListRequest{} } +func (m *CMsgGuildmatePracticeLobbyListRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGuildmatePracticeLobbyListRequest) ProtoMessage() {} +func (*CMsgGuildmatePracticeLobbyListRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{42} +} + +func (m *CMsgGuildmatePracticeLobbyListRequest) GetGuilds() []uint32 { + if m != nil { + return m.Guilds + } + return nil +} + +type CMsgGuildmatePracticeLobbyListResponse struct { + Lobbies []*CMsgPracticeLobbyListResponseEntry `protobuf:"bytes,1,rep,name=lobbies" json:"lobbies,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGuildmatePracticeLobbyListResponse) Reset() { + *m = CMsgGuildmatePracticeLobbyListResponse{} +} +func (m *CMsgGuildmatePracticeLobbyListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGuildmatePracticeLobbyListResponse) ProtoMessage() {} +func (*CMsgGuildmatePracticeLobbyListResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{43} +} + +func (m *CMsgGuildmatePracticeLobbyListResponse) GetLobbies() []*CMsgPracticeLobbyListResponseEntry { + if m != nil { + return m.Lobbies + } + return nil +} + +type CMsgJoinableCustomGameModesRequest struct { + ServerRegion *uint32 `protobuf:"varint,1,opt,name=server_region" json:"server_region,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgJoinableCustomGameModesRequest) Reset() { *m = CMsgJoinableCustomGameModesRequest{} } +func (m *CMsgJoinableCustomGameModesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgJoinableCustomGameModesRequest) ProtoMessage() {} +func (*CMsgJoinableCustomGameModesRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{44} +} + +func (m *CMsgJoinableCustomGameModesRequest) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return 0 +} + +type CMsgJoinableCustomGameModesResponseEntry struct { + CustomGameId *uint64 `protobuf:"varint,1,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + LobbyCount *uint32 `protobuf:"varint,2,opt,name=lobby_count" json:"lobby_count,omitempty"` + PlayerCount *uint32 `protobuf:"varint,3,opt,name=player_count" json:"player_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgJoinableCustomGameModesResponseEntry) Reset() { + *m = CMsgJoinableCustomGameModesResponseEntry{} +} +func (m *CMsgJoinableCustomGameModesResponseEntry) String() string { return proto.CompactTextString(m) } +func (*CMsgJoinableCustomGameModesResponseEntry) ProtoMessage() {} +func (*CMsgJoinableCustomGameModesResponseEntry) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{45} +} + +func (m *CMsgJoinableCustomGameModesResponseEntry) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgJoinableCustomGameModesResponseEntry) GetLobbyCount() uint32 { + if m != nil && m.LobbyCount != nil { + return *m.LobbyCount + } + return 0 +} + +func (m *CMsgJoinableCustomGameModesResponseEntry) GetPlayerCount() uint32 { + if m != nil && m.PlayerCount != nil { + return *m.PlayerCount + } + return 0 +} + +type CMsgJoinableCustomGameModesResponse struct { + GameModes []*CMsgJoinableCustomGameModesResponseEntry `protobuf:"bytes,1,rep,name=game_modes" json:"game_modes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgJoinableCustomGameModesResponse) Reset() { *m = CMsgJoinableCustomGameModesResponse{} } +func (m *CMsgJoinableCustomGameModesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgJoinableCustomGameModesResponse) ProtoMessage() {} +func (*CMsgJoinableCustomGameModesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{46} +} + +func (m *CMsgJoinableCustomGameModesResponse) GetGameModes() []*CMsgJoinableCustomGameModesResponseEntry { + if m != nil { + return m.GameModes + } + return nil +} + +type CMsgJoinableCustomLobbiesRequest struct { + ServerRegion *uint32 `protobuf:"varint,1,opt,name=server_region" json:"server_region,omitempty"` + CustomGameId *uint64 `protobuf:"varint,2,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgJoinableCustomLobbiesRequest) Reset() { *m = CMsgJoinableCustomLobbiesRequest{} } +func (m *CMsgJoinableCustomLobbiesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgJoinableCustomLobbiesRequest) ProtoMessage() {} +func (*CMsgJoinableCustomLobbiesRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{47} +} + +func (m *CMsgJoinableCustomLobbiesRequest) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesRequest) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +type CMsgJoinableCustomLobbiesResponseEntry struct { + LobbyId *uint64 `protobuf:"fixed64,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + CustomGameId *uint64 `protobuf:"varint,2,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + LobbyName *string `protobuf:"bytes,3,opt,name=lobby_name" json:"lobby_name,omitempty"` + MemberCount *uint32 `protobuf:"varint,4,opt,name=member_count" json:"member_count,omitempty"` + LeaderAccountId *uint32 `protobuf:"varint,5,opt,name=leader_account_id" json:"leader_account_id,omitempty"` + LeaderName *string `protobuf:"bytes,6,opt,name=leader_name" json:"leader_name,omitempty"` + CustomMapName *string `protobuf:"bytes,7,opt,name=custom_map_name" json:"custom_map_name,omitempty"` + MaxPlayerCount *uint32 `protobuf:"varint,8,opt,name=max_player_count" json:"max_player_count,omitempty"` + ServerRegion *uint32 `protobuf:"varint,9,opt,name=server_region" json:"server_region,omitempty"` + LanHostPingToServerRegion *uint32 `protobuf:"varint,10,opt,name=lan_host_ping_to_server_region" json:"lan_host_ping_to_server_region,omitempty"` + HasPassKey *bool `protobuf:"varint,11,opt,name=has_pass_key" json:"has_pass_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) Reset() { + *m = CMsgJoinableCustomLobbiesResponseEntry{} +} +func (m *CMsgJoinableCustomLobbiesResponseEntry) String() string { return proto.CompactTextString(m) } +func (*CMsgJoinableCustomLobbiesResponseEntry) ProtoMessage() {} +func (*CMsgJoinableCustomLobbiesResponseEntry) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{48} +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetLobbyName() string { + if m != nil && m.LobbyName != nil { + return *m.LobbyName + } + return "" +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetMemberCount() uint32 { + if m != nil && m.MemberCount != nil { + return *m.MemberCount + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetLeaderAccountId() uint32 { + if m != nil && m.LeaderAccountId != nil { + return *m.LeaderAccountId + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetLeaderName() string { + if m != nil && m.LeaderName != nil { + return *m.LeaderName + } + return "" +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetCustomMapName() string { + if m != nil && m.CustomMapName != nil { + return *m.CustomMapName + } + return "" +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetMaxPlayerCount() uint32 { + if m != nil && m.MaxPlayerCount != nil { + return *m.MaxPlayerCount + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetLanHostPingToServerRegion() uint32 { + if m != nil && m.LanHostPingToServerRegion != nil { + return *m.LanHostPingToServerRegion + } + return 0 +} + +func (m *CMsgJoinableCustomLobbiesResponseEntry) GetHasPassKey() bool { + if m != nil && m.HasPassKey != nil { + return *m.HasPassKey + } + return false +} + +type CMsgJoinableCustomLobbiesResponse struct { + Lobbies []*CMsgJoinableCustomLobbiesResponseEntry `protobuf:"bytes,1,rep,name=lobbies" json:"lobbies,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgJoinableCustomLobbiesResponse) Reset() { *m = CMsgJoinableCustomLobbiesResponse{} } +func (m *CMsgJoinableCustomLobbiesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgJoinableCustomLobbiesResponse) ProtoMessage() {} +func (*CMsgJoinableCustomLobbiesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{49} +} + +func (m *CMsgJoinableCustomLobbiesResponse) GetLobbies() []*CMsgJoinableCustomLobbiesResponseEntry { + if m != nil { + return m.Lobbies + } + return nil +} + +type CMsgQuickJoinCustomLobby struct { + LegacyServerRegion *uint32 `protobuf:"varint,1,opt,name=legacy_server_region" json:"legacy_server_region,omitempty"` + CustomGameId *uint64 `protobuf:"varint,2,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + ClientVersion *uint32 `protobuf:"varint,3,opt,name=client_version" json:"client_version,omitempty"` + CreateLobbyDetails *CMsgPracticeLobbySetDetails `protobuf:"bytes,4,opt,name=create_lobby_details" json:"create_lobby_details,omitempty"` + AllowAnyMap *bool `protobuf:"varint,5,opt,name=allow_any_map" json:"allow_any_map,omitempty"` + LegacyRegionPings []*CMsgQuickJoinCustomLobby_LegacyRegionPing `protobuf:"bytes,6,rep,name=legacy_region_pings" json:"legacy_region_pings,omitempty"` + PingData *CMsgClientPingData `protobuf:"bytes,7,opt,name=ping_data" json:"ping_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgQuickJoinCustomLobby) Reset() { *m = CMsgQuickJoinCustomLobby{} } +func (m *CMsgQuickJoinCustomLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgQuickJoinCustomLobby) ProtoMessage() {} +func (*CMsgQuickJoinCustomLobby) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{50} } + +func (m *CMsgQuickJoinCustomLobby) GetLegacyServerRegion() uint32 { + if m != nil && m.LegacyServerRegion != nil { + return *m.LegacyServerRegion + } + return 0 +} + +func (m *CMsgQuickJoinCustomLobby) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgQuickJoinCustomLobby) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgQuickJoinCustomLobby) GetCreateLobbyDetails() *CMsgPracticeLobbySetDetails { + if m != nil { + return m.CreateLobbyDetails + } + return nil +} + +func (m *CMsgQuickJoinCustomLobby) GetAllowAnyMap() bool { + if m != nil && m.AllowAnyMap != nil { + return *m.AllowAnyMap + } + return false +} + +func (m *CMsgQuickJoinCustomLobby) GetLegacyRegionPings() []*CMsgQuickJoinCustomLobby_LegacyRegionPing { + if m != nil { + return m.LegacyRegionPings + } + return nil +} + +func (m *CMsgQuickJoinCustomLobby) GetPingData() *CMsgClientPingData { + if m != nil { + return m.PingData + } + return nil +} + +type CMsgQuickJoinCustomLobby_LegacyRegionPing struct { + ServerRegion *uint32 `protobuf:"varint,1,opt,name=server_region" json:"server_region,omitempty"` + Ping *uint32 `protobuf:"varint,2,opt,name=ping" json:"ping,omitempty"` + RegionCode *uint32 `protobuf:"fixed32,3,opt,name=region_code" json:"region_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgQuickJoinCustomLobby_LegacyRegionPing) Reset() { + *m = CMsgQuickJoinCustomLobby_LegacyRegionPing{} +} +func (m *CMsgQuickJoinCustomLobby_LegacyRegionPing) String() string { return proto.CompactTextString(m) } +func (*CMsgQuickJoinCustomLobby_LegacyRegionPing) ProtoMessage() {} +func (*CMsgQuickJoinCustomLobby_LegacyRegionPing) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{50, 0} +} + +func (m *CMsgQuickJoinCustomLobby_LegacyRegionPing) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return 0 +} + +func (m *CMsgQuickJoinCustomLobby_LegacyRegionPing) GetPing() uint32 { + if m != nil && m.Ping != nil { + return *m.Ping + } + return 0 +} + +func (m *CMsgQuickJoinCustomLobby_LegacyRegionPing) GetRegionCode() uint32 { + if m != nil && m.RegionCode != nil { + return *m.RegionCode + } + return 0 +} + +type CMsgQuickJoinCustomLobbyResponse struct { + Result *DOTAJoinLobbyResult `protobuf:"varint,1,opt,name=result,enum=DOTAJoinLobbyResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgQuickJoinCustomLobbyResponse) Reset() { *m = CMsgQuickJoinCustomLobbyResponse{} } +func (m *CMsgQuickJoinCustomLobbyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgQuickJoinCustomLobbyResponse) ProtoMessage() {} +func (*CMsgQuickJoinCustomLobbyResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{51} +} + +const Default_CMsgQuickJoinCustomLobbyResponse_Result DOTAJoinLobbyResult = DOTAJoinLobbyResult_DOTA_JOIN_RESULT_SUCCESS + +func (m *CMsgQuickJoinCustomLobbyResponse) GetResult() DOTAJoinLobbyResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgQuickJoinCustomLobbyResponse_Result +} + +type CMsgBotGameCreate struct { + SearchKey *string `protobuf:"bytes,1,opt,name=search_key" json:"search_key,omitempty"` + ClientVersion *uint32 `protobuf:"varint,2,opt,name=client_version" json:"client_version,omitempty"` + Difficulty *DOTABotDifficulty `protobuf:"varint,3,opt,name=difficulty,enum=DOTABotDifficulty,def=0" json:"difficulty,omitempty"` + Team *DOTA_GC_TEAM `protobuf:"varint,4,opt,name=team,enum=DOTA_GC_TEAM,def=0" json:"team,omitempty"` + GameMode *uint32 `protobuf:"varint,5,opt,name=game_mode" json:"game_mode,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgBotGameCreate) Reset() { *m = CMsgBotGameCreate{} } +func (m *CMsgBotGameCreate) String() string { return proto.CompactTextString(m) } +func (*CMsgBotGameCreate) ProtoMessage() {} +func (*CMsgBotGameCreate) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{52} } + +const Default_CMsgBotGameCreate_Difficulty DOTABotDifficulty = DOTABotDifficulty_BOT_DIFFICULTY_PASSIVE +const Default_CMsgBotGameCreate_Team DOTA_GC_TEAM = DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS + +func (m *CMsgBotGameCreate) GetSearchKey() string { + if m != nil && m.SearchKey != nil { + return *m.SearchKey + } + return "" +} + +func (m *CMsgBotGameCreate) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgBotGameCreate) GetDifficulty() DOTABotDifficulty { + if m != nil && m.Difficulty != nil { + return *m.Difficulty + } + return Default_CMsgBotGameCreate_Difficulty +} + +func (m *CMsgBotGameCreate) GetTeam() DOTA_GC_TEAM { + if m != nil && m.Team != nil { + return *m.Team + } + return Default_CMsgBotGameCreate_Team +} + +func (m *CMsgBotGameCreate) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +type CMsgCustomGameCreate struct { + SearchKey *string `protobuf:"bytes,1,opt,name=search_key" json:"search_key,omitempty"` + ClientVersion *uint32 `protobuf:"varint,2,opt,name=client_version" json:"client_version,omitempty"` + Difficulty *uint32 `protobuf:"varint,3,opt,name=difficulty" json:"difficulty,omitempty"` + GameMode *string `protobuf:"bytes,4,opt,name=game_mode" json:"game_mode,omitempty"` + Map *string `protobuf:"bytes,5,opt,name=map" json:"map,omitempty"` + CustomGameId *uint64 `protobuf:"varint,7,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCustomGameCreate) Reset() { *m = CMsgCustomGameCreate{} } +func (m *CMsgCustomGameCreate) String() string { return proto.CompactTextString(m) } +func (*CMsgCustomGameCreate) ProtoMessage() {} +func (*CMsgCustomGameCreate) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{53} } + +func (m *CMsgCustomGameCreate) GetSearchKey() string { + if m != nil && m.SearchKey != nil { + return *m.SearchKey + } + return "" +} + +func (m *CMsgCustomGameCreate) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgCustomGameCreate) GetDifficulty() uint32 { + if m != nil && m.Difficulty != nil { + return *m.Difficulty + } + return 0 +} + +func (m *CMsgCustomGameCreate) GetGameMode() string { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return "" +} + +func (m *CMsgCustomGameCreate) GetMap() string { + if m != nil && m.Map != nil { + return *m.Map + } + return "" +} + +func (m *CMsgCustomGameCreate) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +type CMsgEventGameCreate struct { + SearchKey *string `protobuf:"bytes,1,opt,name=search_key" json:"search_key,omitempty"` + ClientVersion *uint32 `protobuf:"varint,2,opt,name=client_version" json:"client_version,omitempty"` + Difficulty *uint32 `protobuf:"varint,3,opt,name=difficulty" json:"difficulty,omitempty"` + GameMode *string `protobuf:"bytes,4,opt,name=game_mode" json:"game_mode,omitempty"` + Map *string `protobuf:"bytes,5,opt,name=map" json:"map,omitempty"` + CustomGameId *uint64 `protobuf:"varint,7,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgEventGameCreate) Reset() { *m = CMsgEventGameCreate{} } +func (m *CMsgEventGameCreate) String() string { return proto.CompactTextString(m) } +func (*CMsgEventGameCreate) ProtoMessage() {} +func (*CMsgEventGameCreate) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{54} } + +func (m *CMsgEventGameCreate) GetSearchKey() string { + if m != nil && m.SearchKey != nil { + return *m.SearchKey + } + return "" +} + +func (m *CMsgEventGameCreate) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgEventGameCreate) GetDifficulty() uint32 { + if m != nil && m.Difficulty != nil { + return *m.Difficulty + } + return 0 +} + +func (m *CMsgEventGameCreate) GetGameMode() string { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return "" +} + +func (m *CMsgEventGameCreate) GetMap() string { + if m != nil && m.Map != nil { + return *m.Map + } + return "" +} + +func (m *CMsgEventGameCreate) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +type CMsgRequestInternationalTicket struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestInternationalTicket) Reset() { *m = CMsgRequestInternationalTicket{} } +func (m *CMsgRequestInternationalTicket) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestInternationalTicket) ProtoMessage() {} +func (*CMsgRequestInternationalTicket) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{55} } + +type CMsgBalancedShuffleLobby struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgBalancedShuffleLobby) Reset() { *m = CMsgBalancedShuffleLobby{} } +func (m *CMsgBalancedShuffleLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgBalancedShuffleLobby) ProtoMessage() {} +func (*CMsgBalancedShuffleLobby) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{56} } + +type CMsgInitialQuestionnaireResponse struct { + InitialSkill *uint32 `protobuf:"varint,1,opt,name=initial_skill" json:"initial_skill,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgInitialQuestionnaireResponse) Reset() { *m = CMsgInitialQuestionnaireResponse{} } +func (m *CMsgInitialQuestionnaireResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgInitialQuestionnaireResponse) ProtoMessage() {} +func (*CMsgInitialQuestionnaireResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{57} +} + +func (m *CMsgInitialQuestionnaireResponse) GetInitialSkill() uint32 { + if m != nil && m.InitialSkill != nil { + return *m.InitialSkill + } + return 0 +} + +type CMsgDOTAMatch struct { + GoodGuysWin *bool `protobuf:"varint,2,opt,name=good_guys_win" json:"good_guys_win,omitempty"` + Duration *uint32 `protobuf:"varint,3,opt,name=duration" json:"duration,omitempty"` + StartTime *uint32 `protobuf:"fixed32,4,opt,name=startTime" json:"startTime,omitempty"` + Players []*CMsgDOTAMatch_Player `protobuf:"bytes,5,rep,name=players" json:"players,omitempty"` + MatchId *uint64 `protobuf:"varint,6,opt,name=match_id" json:"match_id,omitempty"` + TowerStatus []uint32 `protobuf:"varint,8,rep,name=tower_status" json:"tower_status,omitempty"` + BarracksStatus []uint32 `protobuf:"varint,9,rep,name=barracks_status" json:"barracks_status,omitempty"` + Cluster *uint32 `protobuf:"varint,10,opt,name=cluster" json:"cluster,omitempty"` + FirstBloodTime *uint32 `protobuf:"varint,12,opt,name=first_blood_time" json:"first_blood_time,omitempty"` + ReplaySalt *uint32 `protobuf:"fixed32,13,opt,name=replay_salt" json:"replay_salt,omitempty"` + ServerIp *uint32 `protobuf:"fixed32,14,opt,name=server_ip" json:"server_ip,omitempty"` + ServerPort *uint32 `protobuf:"varint,15,opt,name=server_port" json:"server_port,omitempty"` + LobbyType *uint32 `protobuf:"varint,16,opt,name=lobby_type" json:"lobby_type,omitempty"` + HumanPlayers *uint32 `protobuf:"varint,17,opt,name=human_players" json:"human_players,omitempty"` + AverageSkill *uint32 `protobuf:"varint,18,opt,name=average_skill" json:"average_skill,omitempty"` + GameBalance *float32 `protobuf:"fixed32,19,opt,name=game_balance" json:"game_balance,omitempty"` + RadiantTeamId *uint32 `protobuf:"varint,20,opt,name=radiant_team_id" json:"radiant_team_id,omitempty"` + DireTeamId *uint32 `protobuf:"varint,21,opt,name=dire_team_id" json:"dire_team_id,omitempty"` + Leagueid *uint32 `protobuf:"varint,22,opt,name=leagueid" json:"leagueid,omitempty"` + RadiantTeamName *string `protobuf:"bytes,23,opt,name=radiant_team_name" json:"radiant_team_name,omitempty"` + DireTeamName *string `protobuf:"bytes,24,opt,name=dire_team_name" json:"dire_team_name,omitempty"` + RadiantTeamLogo *uint64 `protobuf:"varint,25,opt,name=radiant_team_logo" json:"radiant_team_logo,omitempty"` + DireTeamLogo *uint64 `protobuf:"varint,26,opt,name=dire_team_logo" json:"dire_team_logo,omitempty"` + RadiantTeamComplete *uint32 `protobuf:"varint,27,opt,name=radiant_team_complete" json:"radiant_team_complete,omitempty"` + DireTeamComplete *uint32 `protobuf:"varint,28,opt,name=dire_team_complete" json:"dire_team_complete,omitempty"` + PositiveVotes *uint32 `protobuf:"varint,29,opt,name=positive_votes" json:"positive_votes,omitempty"` + NegativeVotes *uint32 `protobuf:"varint,30,opt,name=negative_votes" json:"negative_votes,omitempty"` + GameMode *DOTA_GameMode `protobuf:"varint,31,opt,name=game_mode,enum=DOTA_GameMode,def=0" json:"game_mode,omitempty"` + PicksBans []*CMatchHeroSelectEvent `protobuf:"bytes,32,rep,name=picks_bans" json:"picks_bans,omitempty"` + MatchSeqNum *uint64 `protobuf:"varint,33,opt,name=match_seq_num" json:"match_seq_num,omitempty"` + ReplayState *CMsgDOTAMatch_ReplayState `protobuf:"varint,34,opt,name=replay_state,enum=CMsgDOTAMatch_ReplayState,def=0" json:"replay_state,omitempty"` + RadiantGuildId *uint32 `protobuf:"varint,35,opt,name=radiant_guild_id" json:"radiant_guild_id,omitempty"` + DireGuildId *uint32 `protobuf:"varint,36,opt,name=dire_guild_id" json:"dire_guild_id,omitempty"` + RadiantTeamTag *string `protobuf:"bytes,37,opt,name=radiant_team_tag" json:"radiant_team_tag,omitempty"` + DireTeamTag *string `protobuf:"bytes,38,opt,name=dire_team_tag" json:"dire_team_tag,omitempty"` + SeriesId *uint32 `protobuf:"varint,39,opt,name=series_id" json:"series_id,omitempty"` + SeriesType *uint32 `protobuf:"varint,40,opt,name=series_type" json:"series_type,omitempty"` + BroadcasterChannels []*CMsgDOTAMatch_BroadcasterChannel `protobuf:"bytes,43,rep,name=broadcaster_channels" json:"broadcaster_channels,omitempty"` + Engine *uint32 `protobuf:"varint,44,opt,name=engine" json:"engine,omitempty"` + CustomGameData *CMsgDOTAMatch_CustomGameData `protobuf:"bytes,45,opt,name=custom_game_data" json:"custom_game_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatch) Reset() { *m = CMsgDOTAMatch{} } +func (m *CMsgDOTAMatch) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatch) ProtoMessage() {} +func (*CMsgDOTAMatch) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{58} } + +const Default_CMsgDOTAMatch_GameMode DOTA_GameMode = DOTA_GameMode_DOTA_GAMEMODE_NONE +const Default_CMsgDOTAMatch_ReplayState CMsgDOTAMatch_ReplayState = CMsgDOTAMatch_REPLAY_AVAILABLE + +func (m *CMsgDOTAMatch) GetGoodGuysWin() bool { + if m != nil && m.GoodGuysWin != nil { + return *m.GoodGuysWin + } + return false +} + +func (m *CMsgDOTAMatch) GetDuration() uint32 { + if m != nil && m.Duration != nil { + return *m.Duration + } + return 0 +} + +func (m *CMsgDOTAMatch) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgDOTAMatch) GetPlayers() []*CMsgDOTAMatch_Player { + if m != nil { + return m.Players + } + return nil +} + +func (m *CMsgDOTAMatch) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgDOTAMatch) GetTowerStatus() []uint32 { + if m != nil { + return m.TowerStatus + } + return nil +} + +func (m *CMsgDOTAMatch) GetBarracksStatus() []uint32 { + if m != nil { + return m.BarracksStatus + } + return nil +} + +func (m *CMsgDOTAMatch) GetCluster() uint32 { + if m != nil && m.Cluster != nil { + return *m.Cluster + } + return 0 +} + +func (m *CMsgDOTAMatch) GetFirstBloodTime() uint32 { + if m != nil && m.FirstBloodTime != nil { + return *m.FirstBloodTime + } + return 0 +} + +func (m *CMsgDOTAMatch) GetReplaySalt() uint32 { + if m != nil && m.ReplaySalt != nil { + return *m.ReplaySalt + } + return 0 +} + +func (m *CMsgDOTAMatch) GetServerIp() uint32 { + if m != nil && m.ServerIp != nil { + return *m.ServerIp + } + return 0 +} + +func (m *CMsgDOTAMatch) GetServerPort() uint32 { + if m != nil && m.ServerPort != nil { + return *m.ServerPort + } + return 0 +} + +func (m *CMsgDOTAMatch) GetLobbyType() uint32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgDOTAMatch) GetHumanPlayers() uint32 { + if m != nil && m.HumanPlayers != nil { + return *m.HumanPlayers + } + return 0 +} + +func (m *CMsgDOTAMatch) GetAverageSkill() uint32 { + if m != nil && m.AverageSkill != nil { + return *m.AverageSkill + } + return 0 +} + +func (m *CMsgDOTAMatch) GetGameBalance() float32 { + if m != nil && m.GameBalance != nil { + return *m.GameBalance + } + return 0 +} + +func (m *CMsgDOTAMatch) GetRadiantTeamId() uint32 { + if m != nil && m.RadiantTeamId != nil { + return *m.RadiantTeamId + } + return 0 +} + +func (m *CMsgDOTAMatch) GetDireTeamId() uint32 { + if m != nil && m.DireTeamId != nil { + return *m.DireTeamId + } + return 0 +} + +func (m *CMsgDOTAMatch) GetLeagueid() uint32 { + if m != nil && m.Leagueid != nil { + return *m.Leagueid + } + return 0 +} + +func (m *CMsgDOTAMatch) GetRadiantTeamName() string { + if m != nil && m.RadiantTeamName != nil { + return *m.RadiantTeamName + } + return "" +} + +func (m *CMsgDOTAMatch) GetDireTeamName() string { + if m != nil && m.DireTeamName != nil { + return *m.DireTeamName + } + return "" +} + +func (m *CMsgDOTAMatch) GetRadiantTeamLogo() uint64 { + if m != nil && m.RadiantTeamLogo != nil { + return *m.RadiantTeamLogo + } + return 0 +} + +func (m *CMsgDOTAMatch) GetDireTeamLogo() uint64 { + if m != nil && m.DireTeamLogo != nil { + return *m.DireTeamLogo + } + return 0 +} + +func (m *CMsgDOTAMatch) GetRadiantTeamComplete() uint32 { + if m != nil && m.RadiantTeamComplete != nil { + return *m.RadiantTeamComplete + } + return 0 +} + +func (m *CMsgDOTAMatch) GetDireTeamComplete() uint32 { + if m != nil && m.DireTeamComplete != nil { + return *m.DireTeamComplete + } + return 0 +} + +func (m *CMsgDOTAMatch) GetPositiveVotes() uint32 { + if m != nil && m.PositiveVotes != nil { + return *m.PositiveVotes + } + return 0 +} + +func (m *CMsgDOTAMatch) GetNegativeVotes() uint32 { + if m != nil && m.NegativeVotes != nil { + return *m.NegativeVotes + } + return 0 +} + +func (m *CMsgDOTAMatch) GetGameMode() DOTA_GameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return Default_CMsgDOTAMatch_GameMode +} + +func (m *CMsgDOTAMatch) GetPicksBans() []*CMatchHeroSelectEvent { + if m != nil { + return m.PicksBans + } + return nil +} + +func (m *CMsgDOTAMatch) GetMatchSeqNum() uint64 { + if m != nil && m.MatchSeqNum != nil { + return *m.MatchSeqNum + } + return 0 +} + +func (m *CMsgDOTAMatch) GetReplayState() CMsgDOTAMatch_ReplayState { + if m != nil && m.ReplayState != nil { + return *m.ReplayState + } + return Default_CMsgDOTAMatch_ReplayState +} + +func (m *CMsgDOTAMatch) GetRadiantGuildId() uint32 { + if m != nil && m.RadiantGuildId != nil { + return *m.RadiantGuildId + } + return 0 +} + +func (m *CMsgDOTAMatch) GetDireGuildId() uint32 { + if m != nil && m.DireGuildId != nil { + return *m.DireGuildId + } + return 0 +} + +func (m *CMsgDOTAMatch) GetRadiantTeamTag() string { + if m != nil && m.RadiantTeamTag != nil { + return *m.RadiantTeamTag + } + return "" +} + +func (m *CMsgDOTAMatch) GetDireTeamTag() string { + if m != nil && m.DireTeamTag != nil { + return *m.DireTeamTag + } + return "" +} + +func (m *CMsgDOTAMatch) GetSeriesId() uint32 { + if m != nil && m.SeriesId != nil { + return *m.SeriesId + } + return 0 +} + +func (m *CMsgDOTAMatch) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +func (m *CMsgDOTAMatch) GetBroadcasterChannels() []*CMsgDOTAMatch_BroadcasterChannel { + if m != nil { + return m.BroadcasterChannels + } + return nil +} + +func (m *CMsgDOTAMatch) GetEngine() uint32 { + if m != nil && m.Engine != nil { + return *m.Engine + } + return 0 +} + +func (m *CMsgDOTAMatch) GetCustomGameData() *CMsgDOTAMatch_CustomGameData { + if m != nil { + return m.CustomGameData + } + return nil +} + +type CMsgDOTAMatch_Player struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + PlayerSlot *uint32 `protobuf:"varint,2,opt,name=player_slot" json:"player_slot,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + Item_0 *uint32 `protobuf:"varint,4,opt,name=item_0" json:"item_0,omitempty"` + Item_1 *uint32 `protobuf:"varint,5,opt,name=item_1" json:"item_1,omitempty"` + Item_2 *uint32 `protobuf:"varint,6,opt,name=item_2" json:"item_2,omitempty"` + Item_3 *uint32 `protobuf:"varint,7,opt,name=item_3" json:"item_3,omitempty"` + Item_4 *uint32 `protobuf:"varint,8,opt,name=item_4" json:"item_4,omitempty"` + Item_5 *uint32 `protobuf:"varint,9,opt,name=item_5" json:"item_5,omitempty"` + ExpectedTeamContribution *float32 `protobuf:"fixed32,10,opt,name=expected_team_contribution" json:"expected_team_contribution,omitempty"` + ScaledMetric *float32 `protobuf:"fixed32,11,opt,name=scaled_metric" json:"scaled_metric,omitempty"` + PreviousRank *uint32 `protobuf:"varint,12,opt,name=previous_rank" json:"previous_rank,omitempty"` + RankChange *uint32 `protobuf:"varint,13,opt,name=rank_change" json:"rank_change,omitempty"` + SoloRank *bool `protobuf:"varint,49,opt,name=solo_rank" json:"solo_rank,omitempty"` + Kills *uint32 `protobuf:"varint,14,opt,name=kills" json:"kills,omitempty"` + Deaths *uint32 `protobuf:"varint,15,opt,name=deaths" json:"deaths,omitempty"` + Assists *uint32 `protobuf:"varint,16,opt,name=assists" json:"assists,omitempty"` + LeaverStatus *uint32 `protobuf:"varint,17,opt,name=leaver_status" json:"leaver_status,omitempty"` + Gold *uint32 `protobuf:"varint,18,opt,name=gold" json:"gold,omitempty"` + LastHits *uint32 `protobuf:"varint,19,opt,name=last_hits" json:"last_hits,omitempty"` + Denies *uint32 `protobuf:"varint,20,opt,name=denies" json:"denies,omitempty"` + GoldPerMin *uint32 `protobuf:"varint,21,opt,name=gold_per_min" json:"gold_per_min,omitempty"` + XPPerMin *uint32 `protobuf:"varint,22,opt,name=XP_per_min" json:"XP_per_min,omitempty"` + GoldSpent *uint32 `protobuf:"varint,23,opt,name=gold_spent" json:"gold_spent,omitempty"` + HeroDamage *uint32 `protobuf:"varint,24,opt,name=hero_damage" json:"hero_damage,omitempty"` + TowerDamage *uint32 `protobuf:"varint,25,opt,name=tower_damage" json:"tower_damage,omitempty"` + HeroHealing *uint32 `protobuf:"varint,26,opt,name=hero_healing" json:"hero_healing,omitempty"` + Level *uint32 `protobuf:"varint,27,opt,name=level" json:"level,omitempty"` + TimeLastSeen *uint32 `protobuf:"varint,28,opt,name=time_last_seen" json:"time_last_seen,omitempty"` + PlayerName *string `protobuf:"bytes,29,opt,name=player_name" json:"player_name,omitempty"` + SupportAbilityValue *uint32 `protobuf:"varint,30,opt,name=support_ability_value" json:"support_ability_value,omitempty"` + FeedingDetected *bool `protobuf:"varint,32,opt,name=feeding_detected" json:"feeding_detected,omitempty"` + SearchRank *uint32 `protobuf:"varint,34,opt,name=search_rank" json:"search_rank,omitempty"` + SearchRankUncertainty *uint32 `protobuf:"varint,35,opt,name=search_rank_uncertainty" json:"search_rank_uncertainty,omitempty"` + RankUncertaintyChange *int32 `protobuf:"varint,36,opt,name=rank_uncertainty_change" json:"rank_uncertainty_change,omitempty"` + HeroPlayCount *uint32 `protobuf:"varint,37,opt,name=hero_play_count" json:"hero_play_count,omitempty"` + PartyId *uint64 `protobuf:"fixed64,38,opt,name=party_id" json:"party_id,omitempty"` + ScaledKills *float32 `protobuf:"fixed32,39,opt,name=scaled_kills" json:"scaled_kills,omitempty"` + ScaledDeaths *float32 `protobuf:"fixed32,40,opt,name=scaled_deaths" json:"scaled_deaths,omitempty"` + ScaledAssists *float32 `protobuf:"fixed32,41,opt,name=scaled_assists" json:"scaled_assists,omitempty"` + ClaimedFarmGold *uint32 `protobuf:"varint,42,opt,name=claimed_farm_gold" json:"claimed_farm_gold,omitempty"` + SupportGold *uint32 `protobuf:"varint,43,opt,name=support_gold" json:"support_gold,omitempty"` + ClaimedDenies *uint32 `protobuf:"varint,44,opt,name=claimed_denies" json:"claimed_denies,omitempty"` + ClaimedMisses *uint32 `protobuf:"varint,45,opt,name=claimed_misses" json:"claimed_misses,omitempty"` + Misses *uint32 `protobuf:"varint,46,opt,name=misses" json:"misses,omitempty"` + AbilityUpgrades []*CMatchPlayerAbilityUpgrade `protobuf:"bytes,47,rep,name=ability_upgrades" json:"ability_upgrades,omitempty"` + AdditionalUnitsInventory []*CMatchAdditionalUnitInventory `protobuf:"bytes,48,rep,name=additional_units_inventory" json:"additional_units_inventory,omitempty"` + CustomGameData *CMsgDOTAMatch_Player_CustomGameData `protobuf:"bytes,50,opt,name=custom_game_data" json:"custom_game_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatch_Player) Reset() { *m = CMsgDOTAMatch_Player{} } +func (m *CMsgDOTAMatch_Player) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatch_Player) ProtoMessage() {} +func (*CMsgDOTAMatch_Player) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{58, 0} } + +func (m *CMsgDOTAMatch_Player) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetPlayerSlot() uint32 { + if m != nil && m.PlayerSlot != nil { + return *m.PlayerSlot + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetItem_0() uint32 { + if m != nil && m.Item_0 != nil { + return *m.Item_0 + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetItem_1() uint32 { + if m != nil && m.Item_1 != nil { + return *m.Item_1 + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetItem_2() uint32 { + if m != nil && m.Item_2 != nil { + return *m.Item_2 + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetItem_3() uint32 { + if m != nil && m.Item_3 != nil { + return *m.Item_3 + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetItem_4() uint32 { + if m != nil && m.Item_4 != nil { + return *m.Item_4 + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetItem_5() uint32 { + if m != nil && m.Item_5 != nil { + return *m.Item_5 + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetExpectedTeamContribution() float32 { + if m != nil && m.ExpectedTeamContribution != nil { + return *m.ExpectedTeamContribution + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetScaledMetric() float32 { + if m != nil && m.ScaledMetric != nil { + return *m.ScaledMetric + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetPreviousRank() uint32 { + if m != nil && m.PreviousRank != nil { + return *m.PreviousRank + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetRankChange() uint32 { + if m != nil && m.RankChange != nil { + return *m.RankChange + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetSoloRank() bool { + if m != nil && m.SoloRank != nil { + return *m.SoloRank + } + return false +} + +func (m *CMsgDOTAMatch_Player) GetKills() uint32 { + if m != nil && m.Kills != nil { + return *m.Kills + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetDeaths() uint32 { + if m != nil && m.Deaths != nil { + return *m.Deaths + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetAssists() uint32 { + if m != nil && m.Assists != nil { + return *m.Assists + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetLeaverStatus() uint32 { + if m != nil && m.LeaverStatus != nil { + return *m.LeaverStatus + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetGold() uint32 { + if m != nil && m.Gold != nil { + return *m.Gold + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetLastHits() uint32 { + if m != nil && m.LastHits != nil { + return *m.LastHits + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetDenies() uint32 { + if m != nil && m.Denies != nil { + return *m.Denies + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetGoldPerMin() uint32 { + if m != nil && m.GoldPerMin != nil { + return *m.GoldPerMin + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetXPPerMin() uint32 { + if m != nil && m.XPPerMin != nil { + return *m.XPPerMin + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetGoldSpent() uint32 { + if m != nil && m.GoldSpent != nil { + return *m.GoldSpent + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetHeroDamage() uint32 { + if m != nil && m.HeroDamage != nil { + return *m.HeroDamage + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetTowerDamage() uint32 { + if m != nil && m.TowerDamage != nil { + return *m.TowerDamage + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetHeroHealing() uint32 { + if m != nil && m.HeroHealing != nil { + return *m.HeroHealing + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetLevel() uint32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetTimeLastSeen() uint32 { + if m != nil && m.TimeLastSeen != nil { + return *m.TimeLastSeen + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +func (m *CMsgDOTAMatch_Player) GetSupportAbilityValue() uint32 { + if m != nil && m.SupportAbilityValue != nil { + return *m.SupportAbilityValue + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetFeedingDetected() bool { + if m != nil && m.FeedingDetected != nil { + return *m.FeedingDetected + } + return false +} + +func (m *CMsgDOTAMatch_Player) GetSearchRank() uint32 { + if m != nil && m.SearchRank != nil { + return *m.SearchRank + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetSearchRankUncertainty() uint32 { + if m != nil && m.SearchRankUncertainty != nil { + return *m.SearchRankUncertainty + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetRankUncertaintyChange() int32 { + if m != nil && m.RankUncertaintyChange != nil { + return *m.RankUncertaintyChange + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetHeroPlayCount() uint32 { + if m != nil && m.HeroPlayCount != nil { + return *m.HeroPlayCount + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetScaledKills() float32 { + if m != nil && m.ScaledKills != nil { + return *m.ScaledKills + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetScaledDeaths() float32 { + if m != nil && m.ScaledDeaths != nil { + return *m.ScaledDeaths + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetScaledAssists() float32 { + if m != nil && m.ScaledAssists != nil { + return *m.ScaledAssists + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetClaimedFarmGold() uint32 { + if m != nil && m.ClaimedFarmGold != nil { + return *m.ClaimedFarmGold + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetSupportGold() uint32 { + if m != nil && m.SupportGold != nil { + return *m.SupportGold + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetClaimedDenies() uint32 { + if m != nil && m.ClaimedDenies != nil { + return *m.ClaimedDenies + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetClaimedMisses() uint32 { + if m != nil && m.ClaimedMisses != nil { + return *m.ClaimedMisses + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetMisses() uint32 { + if m != nil && m.Misses != nil { + return *m.Misses + } + return 0 +} + +func (m *CMsgDOTAMatch_Player) GetAbilityUpgrades() []*CMatchPlayerAbilityUpgrade { + if m != nil { + return m.AbilityUpgrades + } + return nil +} + +func (m *CMsgDOTAMatch_Player) GetAdditionalUnitsInventory() []*CMatchAdditionalUnitInventory { + if m != nil { + return m.AdditionalUnitsInventory + } + return nil +} + +func (m *CMsgDOTAMatch_Player) GetCustomGameData() *CMsgDOTAMatch_Player_CustomGameData { + if m != nil { + return m.CustomGameData + } + return nil +} + +type CMsgDOTAMatch_Player_CustomGameData struct { + DotaTeam *uint32 `protobuf:"varint,1,opt,name=dota_team" json:"dota_team,omitempty"` + Winner *bool `protobuf:"varint,2,opt,name=winner" json:"winner,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatch_Player_CustomGameData) Reset() { *m = CMsgDOTAMatch_Player_CustomGameData{} } +func (m *CMsgDOTAMatch_Player_CustomGameData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatch_Player_CustomGameData) ProtoMessage() {} +func (*CMsgDOTAMatch_Player_CustomGameData) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{58, 0, 0} +} + +func (m *CMsgDOTAMatch_Player_CustomGameData) GetDotaTeam() uint32 { + if m != nil && m.DotaTeam != nil { + return *m.DotaTeam + } + return 0 +} + +func (m *CMsgDOTAMatch_Player_CustomGameData) GetWinner() bool { + if m != nil && m.Winner != nil { + return *m.Winner + } + return false +} + +type CMsgDOTAMatch_BroadcasterInfo struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatch_BroadcasterInfo) Reset() { *m = CMsgDOTAMatch_BroadcasterInfo{} } +func (m *CMsgDOTAMatch_BroadcasterInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatch_BroadcasterInfo) ProtoMessage() {} +func (*CMsgDOTAMatch_BroadcasterInfo) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{58, 1} +} + +func (m *CMsgDOTAMatch_BroadcasterInfo) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAMatch_BroadcasterInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type CMsgDOTAMatch_BroadcasterChannel struct { + CountryCode *string `protobuf:"bytes,1,opt,name=country_code" json:"country_code,omitempty"` + Description *string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"` + BroadcasterInfos []*CMsgDOTAMatch_BroadcasterInfo `protobuf:"bytes,3,rep,name=broadcaster_infos" json:"broadcaster_infos,omitempty"` + LanguageCode *string `protobuf:"bytes,4,opt,name=language_code" json:"language_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatch_BroadcasterChannel) Reset() { *m = CMsgDOTAMatch_BroadcasterChannel{} } +func (m *CMsgDOTAMatch_BroadcasterChannel) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatch_BroadcasterChannel) ProtoMessage() {} +func (*CMsgDOTAMatch_BroadcasterChannel) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{58, 2} +} + +func (m *CMsgDOTAMatch_BroadcasterChannel) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgDOTAMatch_BroadcasterChannel) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CMsgDOTAMatch_BroadcasterChannel) GetBroadcasterInfos() []*CMsgDOTAMatch_BroadcasterInfo { + if m != nil { + return m.BroadcasterInfos + } + return nil +} + +func (m *CMsgDOTAMatch_BroadcasterChannel) GetLanguageCode() string { + if m != nil && m.LanguageCode != nil { + return *m.LanguageCode + } + return "" +} + +type CMsgDOTAMatch_CustomGameData struct { + CustomGameId *uint64 `protobuf:"varint,1,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + MapName *string `protobuf:"bytes,2,opt,name=map_name" json:"map_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatch_CustomGameData) Reset() { *m = CMsgDOTAMatch_CustomGameData{} } +func (m *CMsgDOTAMatch_CustomGameData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatch_CustomGameData) ProtoMessage() {} +func (*CMsgDOTAMatch_CustomGameData) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{58, 3} +} + +func (m *CMsgDOTAMatch_CustomGameData) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgDOTAMatch_CustomGameData) GetMapName() string { + if m != nil && m.MapName != nil { + return *m.MapName + } + return "" +} + +type CMsgDOTAPlayerMatchHistory struct { + MatchIds []uint64 `protobuf:"varint,1,rep,name=match_ids" json:"match_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPlayerMatchHistory) Reset() { *m = CMsgDOTAPlayerMatchHistory{} } +func (m *CMsgDOTAPlayerMatchHistory) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPlayerMatchHistory) ProtoMessage() {} +func (*CMsgDOTAPlayerMatchHistory) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{59} } + +func (m *CMsgDOTAPlayerMatchHistory) GetMatchIds() []uint64 { + if m != nil { + return m.MatchIds + } + return nil +} + +type CMsgDOTAMatchMinimal struct { + MatchId *uint32 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + StartTime *uint32 `protobuf:"fixed32,2,opt,name=start_time" json:"start_time,omitempty"` + Duration *uint32 `protobuf:"varint,3,opt,name=duration" json:"duration,omitempty"` + GameMode *DOTA_GameMode `protobuf:"varint,4,opt,name=game_mode,enum=DOTA_GameMode,def=0" json:"game_mode,omitempty"` + WinningTeam *uint32 `protobuf:"varint,5,opt,name=winning_team" json:"winning_team,omitempty"` + Players []*CMsgDOTAMatchMinimal_Player `protobuf:"bytes,6,rep,name=players" json:"players,omitempty"` + League *CMsgDOTAMatchMinimal_League `protobuf:"bytes,7,opt,name=league" json:"league,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchMinimal) Reset() { *m = CMsgDOTAMatchMinimal{} } +func (m *CMsgDOTAMatchMinimal) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchMinimal) ProtoMessage() {} +func (*CMsgDOTAMatchMinimal) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{60} } + +const Default_CMsgDOTAMatchMinimal_GameMode DOTA_GameMode = DOTA_GameMode_DOTA_GAMEMODE_NONE + +func (m *CMsgDOTAMatchMinimal) GetMatchId() uint32 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal) GetDuration() uint32 { + if m != nil && m.Duration != nil { + return *m.Duration + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal) GetGameMode() DOTA_GameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return Default_CMsgDOTAMatchMinimal_GameMode +} + +func (m *CMsgDOTAMatchMinimal) GetWinningTeam() uint32 { + if m != nil && m.WinningTeam != nil { + return *m.WinningTeam + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal) GetPlayers() []*CMsgDOTAMatchMinimal_Player { + if m != nil { + return m.Players + } + return nil +} + +func (m *CMsgDOTAMatchMinimal) GetLeague() *CMsgDOTAMatchMinimal_League { + if m != nil { + return m.League + } + return nil +} + +type CMsgDOTAMatchMinimal_Player struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + HeroId *uint32 `protobuf:"varint,2,opt,name=hero_id" json:"hero_id,omitempty"` + Kills *uint32 `protobuf:"varint,3,opt,name=kills" json:"kills,omitempty"` + Deaths *uint32 `protobuf:"varint,4,opt,name=deaths" json:"deaths,omitempty"` + Assists *uint32 `protobuf:"varint,5,opt,name=assists" json:"assists,omitempty"` + Items []uint32 `protobuf:"varint,6,rep,name=items" json:"items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchMinimal_Player) Reset() { *m = CMsgDOTAMatchMinimal_Player{} } +func (m *CMsgDOTAMatchMinimal_Player) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchMinimal_Player) ProtoMessage() {} +func (*CMsgDOTAMatchMinimal_Player) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{60, 0} } + +func (m *CMsgDOTAMatchMinimal_Player) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_Player) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_Player) GetKills() uint32 { + if m != nil && m.Kills != nil { + return *m.Kills + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_Player) GetDeaths() uint32 { + if m != nil && m.Deaths != nil { + return *m.Deaths + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_Player) GetAssists() uint32 { + if m != nil && m.Assists != nil { + return *m.Assists + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_Player) GetItems() []uint32 { + if m != nil { + return m.Items + } + return nil +} + +type CMsgDOTAMatchMinimal_League struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + RadiantTeamId *uint32 `protobuf:"varint,2,opt,name=radiant_team_id" json:"radiant_team_id,omitempty"` + RadiantTeamName *string `protobuf:"bytes,3,opt,name=radiant_team_name" json:"radiant_team_name,omitempty"` + RadiantTeamLogo *uint64 `protobuf:"fixed64,4,opt,name=radiant_team_logo" json:"radiant_team_logo,omitempty"` + DireTeamId *uint32 `protobuf:"varint,5,opt,name=dire_team_id" json:"dire_team_id,omitempty"` + DireTeamName *string `protobuf:"bytes,6,opt,name=dire_team_name" json:"dire_team_name,omitempty"` + DireTeamLogo *uint64 `protobuf:"fixed64,7,opt,name=dire_team_logo" json:"dire_team_logo,omitempty"` + SeriesType *uint32 `protobuf:"varint,8,opt,name=series_type" json:"series_type,omitempty"` + SeriesGame *uint32 `protobuf:"varint,9,opt,name=series_game" json:"series_game,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchMinimal_League) Reset() { *m = CMsgDOTAMatchMinimal_League{} } +func (m *CMsgDOTAMatchMinimal_League) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchMinimal_League) ProtoMessage() {} +func (*CMsgDOTAMatchMinimal_League) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{60, 1} } + +func (m *CMsgDOTAMatchMinimal_League) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_League) GetRadiantTeamId() uint32 { + if m != nil && m.RadiantTeamId != nil { + return *m.RadiantTeamId + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_League) GetRadiantTeamName() string { + if m != nil && m.RadiantTeamName != nil { + return *m.RadiantTeamName + } + return "" +} + +func (m *CMsgDOTAMatchMinimal_League) GetRadiantTeamLogo() uint64 { + if m != nil && m.RadiantTeamLogo != nil { + return *m.RadiantTeamLogo + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_League) GetDireTeamId() uint32 { + if m != nil && m.DireTeamId != nil { + return *m.DireTeamId + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_League) GetDireTeamName() string { + if m != nil && m.DireTeamName != nil { + return *m.DireTeamName + } + return "" +} + +func (m *CMsgDOTAMatchMinimal_League) GetDireTeamLogo() uint64 { + if m != nil && m.DireTeamLogo != nil { + return *m.DireTeamLogo + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_League) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +func (m *CMsgDOTAMatchMinimal_League) GetSeriesGame() uint32 { + if m != nil && m.SeriesGame != nil { + return *m.SeriesGame + } + return 0 +} + +type CMsgDOTAMatchHistoryFilter struct { + MatchIds []uint64 `protobuf:"varint,1,rep,name=match_ids" json:"match_ids,omitempty"` + NewestMatchIdAtLastQuery *uint64 `protobuf:"varint,2,opt,name=newest_match_id_at_last_query" json:"newest_match_id_at_last_query,omitempty"` + TimeLastQuery *uint32 `protobuf:"varint,3,opt,name=time_last_query" json:"time_last_query,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchHistoryFilter) Reset() { *m = CMsgDOTAMatchHistoryFilter{} } +func (m *CMsgDOTAMatchHistoryFilter) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchHistoryFilter) ProtoMessage() {} +func (*CMsgDOTAMatchHistoryFilter) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{61} } + +func (m *CMsgDOTAMatchHistoryFilter) GetMatchIds() []uint64 { + if m != nil { + return m.MatchIds + } + return nil +} + +func (m *CMsgDOTAMatchHistoryFilter) GetNewestMatchIdAtLastQuery() uint64 { + if m != nil && m.NewestMatchIdAtLastQuery != nil { + return *m.NewestMatchIdAtLastQuery + } + return 0 +} + +func (m *CMsgDOTAMatchHistoryFilter) GetTimeLastQuery() uint32 { + if m != nil && m.TimeLastQuery != nil { + return *m.TimeLastQuery + } + return 0 +} + +type CMsgDOTARequestMatches struct { + HeroId *uint32 `protobuf:"varint,2,opt,name=hero_id" json:"hero_id,omitempty"` + GameMode *uint32 `protobuf:"varint,3,opt,name=game_mode" json:"game_mode,omitempty"` + DateMin *uint32 `protobuf:"fixed32,6,opt,name=date_min" json:"date_min,omitempty"` + DateMax *uint32 `protobuf:"fixed32,7,opt,name=date_max" json:"date_max,omitempty"` + MatchesRequested *uint32 `protobuf:"varint,10,opt,name=matches_requested" json:"matches_requested,omitempty"` + StartAtMatchId *uint64 `protobuf:"varint,11,opt,name=start_at_match_id" json:"start_at_match_id,omitempty"` + MinPlayers *uint32 `protobuf:"fixed32,12,opt,name=min_players" json:"min_players,omitempty"` + RequestId *uint32 `protobuf:"varint,13,opt,name=request_id" json:"request_id,omitempty"` + TournamentGamesOnly *bool `protobuf:"varint,14,opt,name=tournament_games_only" json:"tournament_games_only,omitempty"` + AccountId *uint32 `protobuf:"varint,15,opt,name=account_id" json:"account_id,omitempty"` + LeagueId *uint32 `protobuf:"varint,16,opt,name=league_id" json:"league_id,omitempty"` + Skill *CMsgDOTARequestMatches_SkillLevel `protobuf:"varint,17,opt,name=skill,enum=CMsgDOTARequestMatches_SkillLevel,def=0" json:"skill,omitempty"` + TeamId *uint32 `protobuf:"varint,18,opt,name=team_id" json:"team_id,omitempty"` + CustomGameId *uint64 `protobuf:"varint,20,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestMatches) Reset() { *m = CMsgDOTARequestMatches{} } +func (m *CMsgDOTARequestMatches) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestMatches) ProtoMessage() {} +func (*CMsgDOTARequestMatches) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{62} } + +const Default_CMsgDOTARequestMatches_Skill CMsgDOTARequestMatches_SkillLevel = CMsgDOTARequestMatches_Any + +func (m *CMsgDOTARequestMatches) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetDateMin() uint32 { + if m != nil && m.DateMin != nil { + return *m.DateMin + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetDateMax() uint32 { + if m != nil && m.DateMax != nil { + return *m.DateMax + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetMatchesRequested() uint32 { + if m != nil && m.MatchesRequested != nil { + return *m.MatchesRequested + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetStartAtMatchId() uint64 { + if m != nil && m.StartAtMatchId != nil { + return *m.StartAtMatchId + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetMinPlayers() uint32 { + if m != nil && m.MinPlayers != nil { + return *m.MinPlayers + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetTournamentGamesOnly() bool { + if m != nil && m.TournamentGamesOnly != nil { + return *m.TournamentGamesOnly + } + return false +} + +func (m *CMsgDOTARequestMatches) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetSkill() CMsgDOTARequestMatches_SkillLevel { + if m != nil && m.Skill != nil { + return *m.Skill + } + return Default_CMsgDOTARequestMatches_Skill +} + +func (m *CMsgDOTARequestMatches) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTARequestMatches) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +type CMsgDOTARequestMatchesResponse struct { + Matches []*CMsgDOTAMatch `protobuf:"bytes,1,rep,name=matches" json:"matches,omitempty"` + Series []*CMsgDOTARequestMatchesResponse_Series `protobuf:"bytes,2,rep,name=series" json:"series,omitempty"` + RequestId *uint32 `protobuf:"varint,3,opt,name=request_id" json:"request_id,omitempty"` + TotalResults *uint32 `protobuf:"varint,4,opt,name=total_results" json:"total_results,omitempty"` + ResultsRemaining *uint32 `protobuf:"varint,5,opt,name=results_remaining" json:"results_remaining,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestMatchesResponse) Reset() { *m = CMsgDOTARequestMatchesResponse{} } +func (m *CMsgDOTARequestMatchesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestMatchesResponse) ProtoMessage() {} +func (*CMsgDOTARequestMatchesResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{63} } + +func (m *CMsgDOTARequestMatchesResponse) GetMatches() []*CMsgDOTAMatch { + if m != nil { + return m.Matches + } + return nil +} + +func (m *CMsgDOTARequestMatchesResponse) GetSeries() []*CMsgDOTARequestMatchesResponse_Series { + if m != nil { + return m.Series + } + return nil +} + +func (m *CMsgDOTARequestMatchesResponse) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *CMsgDOTARequestMatchesResponse) GetTotalResults() uint32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +func (m *CMsgDOTARequestMatchesResponse) GetResultsRemaining() uint32 { + if m != nil && m.ResultsRemaining != nil { + return *m.ResultsRemaining + } + return 0 +} + +type CMsgDOTARequestMatchesResponse_Series struct { + Matches []*CMsgDOTAMatch `protobuf:"bytes,1,rep,name=matches" json:"matches,omitempty"` + SeriesId *uint32 `protobuf:"varint,2,opt,name=series_id" json:"series_id,omitempty"` + SeriesType *uint32 `protobuf:"varint,3,opt,name=series_type" json:"series_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestMatchesResponse_Series) Reset() { *m = CMsgDOTARequestMatchesResponse_Series{} } +func (m *CMsgDOTARequestMatchesResponse_Series) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestMatchesResponse_Series) ProtoMessage() {} +func (*CMsgDOTARequestMatchesResponse_Series) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{63, 0} +} + +func (m *CMsgDOTARequestMatchesResponse_Series) GetMatches() []*CMsgDOTAMatch { + if m != nil { + return m.Matches + } + return nil +} + +func (m *CMsgDOTARequestMatchesResponse_Series) GetSeriesId() uint32 { + if m != nil && m.SeriesId != nil { + return *m.SeriesId + } + return 0 +} + +func (m *CMsgDOTARequestMatchesResponse_Series) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +type CMsgDOTAPopup struct { + Id *CMsgDOTAPopup_PopupID `protobuf:"varint,1,opt,name=id,enum=CMsgDOTAPopup_PopupID,def=0" json:"id,omitempty"` + CustomText *string `protobuf:"bytes,2,opt,name=custom_text" json:"custom_text,omitempty"` + IntData *int32 `protobuf:"zigzag32,3,opt,name=int_data" json:"int_data,omitempty"` + PopupData []byte `protobuf:"bytes,4,opt,name=popup_data" json:"popup_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPopup) Reset() { *m = CMsgDOTAPopup{} } +func (m *CMsgDOTAPopup) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPopup) ProtoMessage() {} +func (*CMsgDOTAPopup) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{64} } + +const Default_CMsgDOTAPopup_Id CMsgDOTAPopup_PopupID = CMsgDOTAPopup_KICKED_FROM_LOBBY + +func (m *CMsgDOTAPopup) GetId() CMsgDOTAPopup_PopupID { + if m != nil && m.Id != nil { + return *m.Id + } + return Default_CMsgDOTAPopup_Id +} + +func (m *CMsgDOTAPopup) GetCustomText() string { + if m != nil && m.CustomText != nil { + return *m.CustomText + } + return "" +} + +func (m *CMsgDOTAPopup) GetIntData() int32 { + if m != nil && m.IntData != nil { + return *m.IntData + } + return 0 +} + +func (m *CMsgDOTAPopup) GetPopupData() []byte { + if m != nil { + return m.PopupData + } + return nil +} + +type CMsgDOTATeamMemberSDO struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + TeamIds []uint32 `protobuf:"varint,2,rep,name=team_ids" json:"team_ids,omitempty"` + ProfileTeamId *uint32 `protobuf:"varint,3,opt,name=profile_team_id" json:"profile_team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamMemberSDO) Reset() { *m = CMsgDOTATeamMemberSDO{} } +func (m *CMsgDOTATeamMemberSDO) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamMemberSDO) ProtoMessage() {} +func (*CMsgDOTATeamMemberSDO) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{65} } + +func (m *CMsgDOTATeamMemberSDO) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTATeamMemberSDO) GetTeamIds() []uint32 { + if m != nil { + return m.TeamIds + } + return nil +} + +func (m *CMsgDOTATeamMemberSDO) GetProfileTeamId() uint32 { + if m != nil && m.ProfileTeamId != nil { + return *m.ProfileTeamId + } + return 0 +} + +type CMsgDOTATeamAdminSDO struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + TeamIds []uint32 `protobuf:"varint,2,rep,name=team_ids" json:"team_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamAdminSDO) Reset() { *m = CMsgDOTATeamAdminSDO{} } +func (m *CMsgDOTATeamAdminSDO) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamAdminSDO) ProtoMessage() {} +func (*CMsgDOTATeamAdminSDO) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{66} } + +func (m *CMsgDOTATeamAdminSDO) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTATeamAdminSDO) GetTeamIds() []uint32 { + if m != nil { + return m.TeamIds + } + return nil +} + +type CMsgDOTATeamMember struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + TimeJoined *uint32 `protobuf:"varint,4,opt,name=time_joined" json:"time_joined,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamMember) Reset() { *m = CMsgDOTATeamMember{} } +func (m *CMsgDOTATeamMember) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamMember) ProtoMessage() {} +func (*CMsgDOTATeamMember) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{67} } + +func (m *CMsgDOTATeamMember) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTATeamMember) GetTimeJoined() uint32 { + if m != nil && m.TimeJoined != nil { + return *m.TimeJoined + } + return 0 +} + +type CMsgDOTATeam struct { + Members []*CMsgDOTATeamMember `protobuf:"bytes,1,rep,name=members" json:"members,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` + Tag *string `protobuf:"bytes,4,opt,name=tag" json:"tag,omitempty"` + AdminId *uint32 `protobuf:"varint,5,opt,name=admin_id" json:"admin_id,omitempty"` + TimeCreated *uint32 `protobuf:"varint,6,opt,name=time_created" json:"time_created,omitempty"` + Disbanded *bool `protobuf:"varint,7,opt,name=disbanded" json:"disbanded,omitempty"` + Wins *uint32 `protobuf:"varint,8,opt,name=wins" json:"wins,omitempty"` + Losses *uint32 `protobuf:"varint,9,opt,name=losses" json:"losses,omitempty"` + Rank *uint32 `protobuf:"varint,10,opt,name=rank" json:"rank,omitempty"` + CalibrationGamesRemaining *uint32 `protobuf:"varint,24,opt,name=calibration_games_remaining" json:"calibration_games_remaining,omitempty"` + Logo *uint64 `protobuf:"varint,11,opt,name=logo" json:"logo,omitempty"` + BaseLogo *uint64 `protobuf:"varint,12,opt,name=base_logo" json:"base_logo,omitempty"` + BannerLogo *uint64 `protobuf:"varint,13,opt,name=banner_logo" json:"banner_logo,omitempty"` + SponsorLogo *uint64 `protobuf:"varint,14,opt,name=sponsor_logo" json:"sponsor_logo,omitempty"` + CountryCode *string `protobuf:"bytes,15,opt,name=country_code" json:"country_code,omitempty"` + Url *string `protobuf:"bytes,16,opt,name=url" json:"url,omitempty"` + Fullgamesplayed *uint32 `protobuf:"varint,17,opt,name=fullgamesplayed" json:"fullgamesplayed,omitempty"` + Leagues []uint32 `protobuf:"varint,18,rep,name=leagues" json:"leagues,omitempty"` + Gamesplayed *uint32 `protobuf:"varint,19,opt,name=gamesplayed" json:"gamesplayed,omitempty"` + Gamesplayedwithcurrentroster *uint32 `protobuf:"varint,20,opt,name=gamesplayedwithcurrentroster" json:"gamesplayedwithcurrentroster,omitempty"` + Teammatchmakinggamesplayed *uint32 `protobuf:"varint,21,opt,name=teammatchmakinggamesplayed" json:"teammatchmakinggamesplayed,omitempty"` + Lastplayedgametime *uint32 `protobuf:"varint,22,opt,name=lastplayedgametime" json:"lastplayedgametime,omitempty"` + Lastrenametime *uint32 `protobuf:"varint,23,opt,name=lastrenametime" json:"lastrenametime,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeam) Reset() { *m = CMsgDOTATeam{} } +func (m *CMsgDOTATeam) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeam) ProtoMessage() {} +func (*CMsgDOTATeam) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{68} } + +func (m *CMsgDOTATeam) GetMembers() []*CMsgDOTATeamMember { + if m != nil { + return m.Members + } + return nil +} + +func (m *CMsgDOTATeam) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTATeam) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTATeam) GetTag() string { + if m != nil && m.Tag != nil { + return *m.Tag + } + return "" +} + +func (m *CMsgDOTATeam) GetAdminId() uint32 { + if m != nil && m.AdminId != nil { + return *m.AdminId + } + return 0 +} + +func (m *CMsgDOTATeam) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *CMsgDOTATeam) GetDisbanded() bool { + if m != nil && m.Disbanded != nil { + return *m.Disbanded + } + return false +} + +func (m *CMsgDOTATeam) GetWins() uint32 { + if m != nil && m.Wins != nil { + return *m.Wins + } + return 0 +} + +func (m *CMsgDOTATeam) GetLosses() uint32 { + if m != nil && m.Losses != nil { + return *m.Losses + } + return 0 +} + +func (m *CMsgDOTATeam) GetRank() uint32 { + if m != nil && m.Rank != nil { + return *m.Rank + } + return 0 +} + +func (m *CMsgDOTATeam) GetCalibrationGamesRemaining() uint32 { + if m != nil && m.CalibrationGamesRemaining != nil { + return *m.CalibrationGamesRemaining + } + return 0 +} + +func (m *CMsgDOTATeam) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTATeam) GetBaseLogo() uint64 { + if m != nil && m.BaseLogo != nil { + return *m.BaseLogo + } + return 0 +} + +func (m *CMsgDOTATeam) GetBannerLogo() uint64 { + if m != nil && m.BannerLogo != nil { + return *m.BannerLogo + } + return 0 +} + +func (m *CMsgDOTATeam) GetSponsorLogo() uint64 { + if m != nil && m.SponsorLogo != nil { + return *m.SponsorLogo + } + return 0 +} + +func (m *CMsgDOTATeam) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgDOTATeam) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CMsgDOTATeam) GetFullgamesplayed() uint32 { + if m != nil && m.Fullgamesplayed != nil { + return *m.Fullgamesplayed + } + return 0 +} + +func (m *CMsgDOTATeam) GetLeagues() []uint32 { + if m != nil { + return m.Leagues + } + return nil +} + +func (m *CMsgDOTATeam) GetGamesplayed() uint32 { + if m != nil && m.Gamesplayed != nil { + return *m.Gamesplayed + } + return 0 +} + +func (m *CMsgDOTATeam) GetGamesplayedwithcurrentroster() uint32 { + if m != nil && m.Gamesplayedwithcurrentroster != nil { + return *m.Gamesplayedwithcurrentroster + } + return 0 +} + +func (m *CMsgDOTATeam) GetTeammatchmakinggamesplayed() uint32 { + if m != nil && m.Teammatchmakinggamesplayed != nil { + return *m.Teammatchmakinggamesplayed + } + return 0 +} + +func (m *CMsgDOTATeam) GetLastplayedgametime() uint32 { + if m != nil && m.Lastplayedgametime != nil { + return *m.Lastplayedgametime + } + return 0 +} + +func (m *CMsgDOTATeam) GetLastrenametime() uint32 { + if m != nil && m.Lastrenametime != nil { + return *m.Lastrenametime + } + return 0 +} + +type CMsgDOTACreateTeam struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Tag *string `protobuf:"bytes,2,opt,name=tag" json:"tag,omitempty"` + Logo *uint64 `protobuf:"varint,3,opt,name=logo" json:"logo,omitempty"` + BaseLogo *uint64 `protobuf:"varint,4,opt,name=base_logo" json:"base_logo,omitempty"` + BannerLogo *uint64 `protobuf:"varint,5,opt,name=banner_logo" json:"banner_logo,omitempty"` + SponsorLogo *uint64 `protobuf:"varint,6,opt,name=sponsor_logo" json:"sponsor_logo,omitempty"` + CountryCode *string `protobuf:"bytes,7,opt,name=country_code" json:"country_code,omitempty"` + Url *string `protobuf:"bytes,8,opt,name=url" json:"url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACreateTeam) Reset() { *m = CMsgDOTACreateTeam{} } +func (m *CMsgDOTACreateTeam) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACreateTeam) ProtoMessage() {} +func (*CMsgDOTACreateTeam) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{69} } + +func (m *CMsgDOTACreateTeam) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTACreateTeam) GetTag() string { + if m != nil && m.Tag != nil { + return *m.Tag + } + return "" +} + +func (m *CMsgDOTACreateTeam) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTACreateTeam) GetBaseLogo() uint64 { + if m != nil && m.BaseLogo != nil { + return *m.BaseLogo + } + return 0 +} + +func (m *CMsgDOTACreateTeam) GetBannerLogo() uint64 { + if m != nil && m.BannerLogo != nil { + return *m.BannerLogo + } + return 0 +} + +func (m *CMsgDOTACreateTeam) GetSponsorLogo() uint64 { + if m != nil && m.SponsorLogo != nil { + return *m.SponsorLogo + } + return 0 +} + +func (m *CMsgDOTACreateTeam) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgDOTACreateTeam) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +type CMsgDOTACreateTeamResponse struct { + Results []CMsgDOTACreateTeamResponse_Result `protobuf:"varint,1,rep,name=results,enum=CMsgDOTACreateTeamResponse_Result" json:"results,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + SecondsRemaining *uint32 `protobuf:"varint,3,opt,name=seconds_remaining" json:"seconds_remaining,omitempty"` + RequiredLevel *uint32 `protobuf:"varint,4,opt,name=required_level" json:"required_level,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACreateTeamResponse) Reset() { *m = CMsgDOTACreateTeamResponse{} } +func (m *CMsgDOTACreateTeamResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACreateTeamResponse) ProtoMessage() {} +func (*CMsgDOTACreateTeamResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{70} } + +func (m *CMsgDOTACreateTeamResponse) GetResults() []CMsgDOTACreateTeamResponse_Result { + if m != nil { + return m.Results + } + return nil +} + +func (m *CMsgDOTACreateTeamResponse) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTACreateTeamResponse) GetSecondsRemaining() uint32 { + if m != nil && m.SecondsRemaining != nil { + return *m.SecondsRemaining + } + return 0 +} + +func (m *CMsgDOTACreateTeamResponse) GetRequiredLevel() uint32 { + if m != nil && m.RequiredLevel != nil { + return *m.RequiredLevel + } + return 0 +} + +type CMsgDOTAEditTeam struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Tag *string `protobuf:"bytes,2,opt,name=tag" json:"tag,omitempty"` + Logo *uint64 `protobuf:"varint,3,opt,name=logo" json:"logo,omitempty"` + BaseLogo *uint64 `protobuf:"varint,4,opt,name=base_logo" json:"base_logo,omitempty"` + BannerLogo *uint64 `protobuf:"varint,5,opt,name=banner_logo" json:"banner_logo,omitempty"` + SponsorLogo *uint64 `protobuf:"varint,6,opt,name=sponsor_logo" json:"sponsor_logo,omitempty"` + CountryCode *string `protobuf:"bytes,7,opt,name=country_code" json:"country_code,omitempty"` + Url *string `protobuf:"bytes,8,opt,name=url" json:"url,omitempty"` + TeamId *uint32 `protobuf:"varint,9,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEditTeam) Reset() { *m = CMsgDOTAEditTeam{} } +func (m *CMsgDOTAEditTeam) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEditTeam) ProtoMessage() {} +func (*CMsgDOTAEditTeam) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{71} } + +func (m *CMsgDOTAEditTeam) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTAEditTeam) GetTag() string { + if m != nil && m.Tag != nil { + return *m.Tag + } + return "" +} + +func (m *CMsgDOTAEditTeam) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAEditTeam) GetBaseLogo() uint64 { + if m != nil && m.BaseLogo != nil { + return *m.BaseLogo + } + return 0 +} + +func (m *CMsgDOTAEditTeam) GetBannerLogo() uint64 { + if m != nil && m.BannerLogo != nil { + return *m.BannerLogo + } + return 0 +} + +func (m *CMsgDOTAEditTeam) GetSponsorLogo() uint64 { + if m != nil && m.SponsorLogo != nil { + return *m.SponsorLogo + } + return 0 +} + +func (m *CMsgDOTAEditTeam) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgDOTAEditTeam) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CMsgDOTAEditTeam) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTAEditTeamLogo struct { + Logo *uint64 `protobuf:"varint,1,opt,name=logo" json:"logo,omitempty"` + BaseLogo *uint64 `protobuf:"varint,2,opt,name=base_logo" json:"base_logo,omitempty"` + BannerLogo *uint64 `protobuf:"varint,3,opt,name=banner_logo" json:"banner_logo,omitempty"` + SponsorLogo *uint64 `protobuf:"varint,4,opt,name=sponsor_logo" json:"sponsor_logo,omitempty"` + TeamId *uint32 `protobuf:"varint,5,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEditTeamLogo) Reset() { *m = CMsgDOTAEditTeamLogo{} } +func (m *CMsgDOTAEditTeamLogo) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEditTeamLogo) ProtoMessage() {} +func (*CMsgDOTAEditTeamLogo) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{72} } + +func (m *CMsgDOTAEditTeamLogo) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAEditTeamLogo) GetBaseLogo() uint64 { + if m != nil && m.BaseLogo != nil { + return *m.BaseLogo + } + return 0 +} + +func (m *CMsgDOTAEditTeamLogo) GetBannerLogo() uint64 { + if m != nil && m.BannerLogo != nil { + return *m.BannerLogo + } + return 0 +} + +func (m *CMsgDOTAEditTeamLogo) GetSponsorLogo() uint64 { + if m != nil && m.SponsorLogo != nil { + return *m.SponsorLogo + } + return 0 +} + +func (m *CMsgDOTAEditTeamLogo) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTAEditTeamLogoResponse struct { + Results []CMsgDOTAEditTeamLogoResponse_Result `protobuf:"varint,1,rep,name=results,enum=CMsgDOTAEditTeamLogoResponse_Result" json:"results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEditTeamLogoResponse) Reset() { *m = CMsgDOTAEditTeamLogoResponse{} } +func (m *CMsgDOTAEditTeamLogoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEditTeamLogoResponse) ProtoMessage() {} +func (*CMsgDOTAEditTeamLogoResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{73} } + +func (m *CMsgDOTAEditTeamLogoResponse) GetResults() []CMsgDOTAEditTeamLogoResponse_Result { + if m != nil { + return m.Results + } + return nil +} + +type CMsgDOTAEditTeamDetails struct { + CountryCode *string `protobuf:"bytes,1,opt,name=country_code" json:"country_code,omitempty"` + Url *string `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"` + TeamId *uint32 `protobuf:"varint,3,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEditTeamDetails) Reset() { *m = CMsgDOTAEditTeamDetails{} } +func (m *CMsgDOTAEditTeamDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEditTeamDetails) ProtoMessage() {} +func (*CMsgDOTAEditTeamDetails) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{74} } + +func (m *CMsgDOTAEditTeamDetails) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgDOTAEditTeamDetails) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CMsgDOTAEditTeamDetails) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTAEditTeamDetailsResponse struct { + Results []CMsgDOTAEditTeamDetailsResponse_Result `protobuf:"varint,1,rep,name=results,enum=CMsgDOTAEditTeamDetailsResponse_Result" json:"results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEditTeamDetailsResponse) Reset() { *m = CMsgDOTAEditTeamDetailsResponse{} } +func (m *CMsgDOTAEditTeamDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEditTeamDetailsResponse) ProtoMessage() {} +func (*CMsgDOTAEditTeamDetailsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{75} +} + +func (m *CMsgDOTAEditTeamDetailsResponse) GetResults() []CMsgDOTAEditTeamDetailsResponse_Result { + if m != nil { + return m.Results + } + return nil +} + +type CMsgDOTADisbandTeam struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTADisbandTeam) Reset() { *m = CMsgDOTADisbandTeam{} } +func (m *CMsgDOTADisbandTeam) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTADisbandTeam) ProtoMessage() {} +func (*CMsgDOTADisbandTeam) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{76} } + +func (m *CMsgDOTADisbandTeam) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTADisbandTeamResponse struct { + Result *CMsgDOTADisbandTeamResponse_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTADisbandTeamResponse_Result,def=0" json:"result,omitempty"` + TeamName *string `protobuf:"bytes,2,opt,name=team_name" json:"team_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTADisbandTeamResponse) Reset() { *m = CMsgDOTADisbandTeamResponse{} } +func (m *CMsgDOTADisbandTeamResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTADisbandTeamResponse) ProtoMessage() {} +func (*CMsgDOTADisbandTeamResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{77} } + +const Default_CMsgDOTADisbandTeamResponse_Result CMsgDOTADisbandTeamResponse_Result = CMsgDOTADisbandTeamResponse_SUCCESS + +func (m *CMsgDOTADisbandTeamResponse) GetResult() CMsgDOTADisbandTeamResponse_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTADisbandTeamResponse_Result +} + +func (m *CMsgDOTADisbandTeamResponse) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +type CMsgDOTARequestTeamData struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestTeamData) Reset() { *m = CMsgDOTARequestTeamData{} } +func (m *CMsgDOTARequestTeamData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestTeamData) ProtoMessage() {} +func (*CMsgDOTARequestTeamData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{78} } + +type CMsgDOTARequestTeamDataResponse struct { + Result *CMsgDOTARequestTeamDataResponse_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTARequestTeamDataResponse_Result,def=0" json:"result,omitempty"` + Data []*CMsgDOTATeamData `protobuf:"bytes,2,rep,name=data" json:"data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestTeamDataResponse) Reset() { *m = CMsgDOTARequestTeamDataResponse{} } +func (m *CMsgDOTARequestTeamDataResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestTeamDataResponse) ProtoMessage() {} +func (*CMsgDOTARequestTeamDataResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{79} +} + +const Default_CMsgDOTARequestTeamDataResponse_Result CMsgDOTARequestTeamDataResponse_Result = CMsgDOTARequestTeamDataResponse_SUCCESS + +func (m *CMsgDOTARequestTeamDataResponse) GetResult() CMsgDOTARequestTeamDataResponse_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTARequestTeamDataResponse_Result +} + +func (m *CMsgDOTARequestTeamDataResponse) GetData() []*CMsgDOTATeamData { + if m != nil { + return m.Data + } + return nil +} + +type CMsgDOTATeamData struct { + OnTeam *bool `protobuf:"varint,1,opt,name=on_team" json:"on_team,omitempty"` + ProfileTeam *bool `protobuf:"varint,2,opt,name=profile_team" json:"profile_team,omitempty"` + Team *CMsgDOTATeam `protobuf:"bytes,3,opt,name=team" json:"team,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamData) Reset() { *m = CMsgDOTATeamData{} } +func (m *CMsgDOTATeamData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamData) ProtoMessage() {} +func (*CMsgDOTATeamData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{80} } + +func (m *CMsgDOTATeamData) GetOnTeam() bool { + if m != nil && m.OnTeam != nil { + return *m.OnTeam + } + return false +} + +func (m *CMsgDOTATeamData) GetProfileTeam() bool { + if m != nil && m.ProfileTeam != nil { + return *m.ProfileTeam + } + return false +} + +func (m *CMsgDOTATeamData) GetTeam() *CMsgDOTATeam { + if m != nil { + return m.Team + } + return nil +} + +type CMsgDOTATeamProfileRequest struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamProfileRequest) Reset() { *m = CMsgDOTATeamProfileRequest{} } +func (m *CMsgDOTATeamProfileRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamProfileRequest) ProtoMessage() {} +func (*CMsgDOTATeamProfileRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{81} } + +func (m *CMsgDOTATeamProfileRequest) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTATeamMemberProfileRequest struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamMemberProfileRequest) Reset() { *m = CMsgDOTATeamMemberProfileRequest{} } +func (m *CMsgDOTATeamMemberProfileRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamMemberProfileRequest) ProtoMessage() {} +func (*CMsgDOTATeamMemberProfileRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{82} +} + +func (m *CMsgDOTATeamMemberProfileRequest) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CMsgDOTATeamIDByNameRequest struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamIDByNameRequest) Reset() { *m = CMsgDOTATeamIDByNameRequest{} } +func (m *CMsgDOTATeamIDByNameRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamIDByNameRequest) ProtoMessage() {} +func (*CMsgDOTATeamIDByNameRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{83} } + +func (m *CMsgDOTATeamIDByNameRequest) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type CMsgDOTATeamIDByNameResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamIDByNameResponse) Reset() { *m = CMsgDOTATeamIDByNameResponse{} } +func (m *CMsgDOTATeamIDByNameResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamIDByNameResponse) ProtoMessage() {} +func (*CMsgDOTATeamIDByNameResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{84} } + +func (m *CMsgDOTATeamIDByNameResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgDOTATeamIDByNameResponse) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTATeamProfileResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + Team *CMsgDOTATeam `protobuf:"bytes,2,opt,name=team" json:"team,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamProfileResponse) Reset() { *m = CMsgDOTATeamProfileResponse{} } +func (m *CMsgDOTATeamProfileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamProfileResponse) ProtoMessage() {} +func (*CMsgDOTATeamProfileResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{85} } + +func (m *CMsgDOTATeamProfileResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgDOTATeamProfileResponse) GetTeam() *CMsgDOTATeam { + if m != nil { + return m.Team + } + return nil +} + +type CMsgDOTAProTeamListRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProTeamListRequest) Reset() { *m = CMsgDOTAProTeamListRequest{} } +func (m *CMsgDOTAProTeamListRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProTeamListRequest) ProtoMessage() {} +func (*CMsgDOTAProTeamListRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{86} } + +type CMsgDOTAProTeamListResponse struct { + Teams []*CMsgDOTAProTeamListResponse_TeamEntry `protobuf:"bytes,1,rep,name=teams" json:"teams,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProTeamListResponse) Reset() { *m = CMsgDOTAProTeamListResponse{} } +func (m *CMsgDOTAProTeamListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProTeamListResponse) ProtoMessage() {} +func (*CMsgDOTAProTeamListResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{87} } + +func (m *CMsgDOTAProTeamListResponse) GetTeams() []*CMsgDOTAProTeamListResponse_TeamEntry { + if m != nil { + return m.Teams + } + return nil +} + +func (m *CMsgDOTAProTeamListResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgDOTAProTeamListResponse_TeamEntry struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + Tag *string `protobuf:"bytes,2,opt,name=tag" json:"tag,omitempty"` + TimeCreated *uint32 `protobuf:"varint,3,opt,name=time_created" json:"time_created,omitempty"` + Logo *uint64 `protobuf:"varint,4,opt,name=logo" json:"logo,omitempty"` + CountryCode *string `protobuf:"bytes,5,opt,name=country_code" json:"country_code,omitempty"` + MemberCount *uint32 `protobuf:"varint,6,opt,name=member_count" json:"member_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProTeamListResponse_TeamEntry) Reset() { *m = CMsgDOTAProTeamListResponse_TeamEntry{} } +func (m *CMsgDOTAProTeamListResponse_TeamEntry) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProTeamListResponse_TeamEntry) ProtoMessage() {} +func (*CMsgDOTAProTeamListResponse_TeamEntry) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{87, 0} +} + +func (m *CMsgDOTAProTeamListResponse_TeamEntry) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTAProTeamListResponse_TeamEntry) GetTag() string { + if m != nil && m.Tag != nil { + return *m.Tag + } + return "" +} + +func (m *CMsgDOTAProTeamListResponse_TeamEntry) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *CMsgDOTAProTeamListResponse_TeamEntry) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAProTeamListResponse_TeamEntry) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgDOTAProTeamListResponse_TeamEntry) GetMemberCount() uint32 { + if m != nil && m.MemberCount != nil { + return *m.MemberCount + } + return 0 +} + +type CMsgDOTATeamInvite_InviterToGC struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamInvite_InviterToGC) Reset() { *m = CMsgDOTATeamInvite_InviterToGC{} } +func (m *CMsgDOTATeamInvite_InviterToGC) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamInvite_InviterToGC) ProtoMessage() {} +func (*CMsgDOTATeamInvite_InviterToGC) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{88} } + +func (m *CMsgDOTATeamInvite_InviterToGC) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTATeamInvite_InviterToGC) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTATeamInvite_GCImmediateResponseToInviter struct { + Result *CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result,def=0" json:"result,omitempty"` + InviteeName *string `protobuf:"bytes,2,opt,name=invitee_name" json:"invitee_name,omitempty"` + RequiredLevel *uint32 `protobuf:"varint,3,opt,name=required_level" json:"required_level,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamInvite_GCImmediateResponseToInviter) Reset() { + *m = CMsgDOTATeamInvite_GCImmediateResponseToInviter{} +} +func (m *CMsgDOTATeamInvite_GCImmediateResponseToInviter) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTATeamInvite_GCImmediateResponseToInviter) ProtoMessage() {} +func (*CMsgDOTATeamInvite_GCImmediateResponseToInviter) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{89} +} + +const Default_CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result = CMsgDOTATeamInvite_GCImmediateResponseToInviter_SUCCESS + +func (m *CMsgDOTATeamInvite_GCImmediateResponseToInviter) GetResult() CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result +} + +func (m *CMsgDOTATeamInvite_GCImmediateResponseToInviter) GetInviteeName() string { + if m != nil && m.InviteeName != nil { + return *m.InviteeName + } + return "" +} + +func (m *CMsgDOTATeamInvite_GCImmediateResponseToInviter) GetRequiredLevel() uint32 { + if m != nil && m.RequiredLevel != nil { + return *m.RequiredLevel + } + return 0 +} + +type CMsgDOTATeamInvite_GCRequestToInvitee struct { + InviterAccountId *uint32 `protobuf:"varint,1,opt,name=inviter_account_id" json:"inviter_account_id,omitempty"` + TeamName *string `protobuf:"bytes,2,opt,name=team_name" json:"team_name,omitempty"` + TeamTag *string `protobuf:"bytes,3,opt,name=team_tag" json:"team_tag,omitempty"` + Logo *uint64 `protobuf:"varint,4,opt,name=logo" json:"logo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamInvite_GCRequestToInvitee) Reset() { *m = CMsgDOTATeamInvite_GCRequestToInvitee{} } +func (m *CMsgDOTATeamInvite_GCRequestToInvitee) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamInvite_GCRequestToInvitee) ProtoMessage() {} +func (*CMsgDOTATeamInvite_GCRequestToInvitee) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{90} +} + +func (m *CMsgDOTATeamInvite_GCRequestToInvitee) GetInviterAccountId() uint32 { + if m != nil && m.InviterAccountId != nil { + return *m.InviterAccountId + } + return 0 +} + +func (m *CMsgDOTATeamInvite_GCRequestToInvitee) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTATeamInvite_GCRequestToInvitee) GetTeamTag() string { + if m != nil && m.TeamTag != nil { + return *m.TeamTag + } + return "" +} + +func (m *CMsgDOTATeamInvite_GCRequestToInvitee) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +type CMsgDOTATeamInvite_InviteeResponseToGC struct { + Result *CMsgDOTATeamInvite_InviteeResponseToGC_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTATeamInvite_InviteeResponseToGC_Result,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamInvite_InviteeResponseToGC) Reset() { + *m = CMsgDOTATeamInvite_InviteeResponseToGC{} +} +func (m *CMsgDOTATeamInvite_InviteeResponseToGC) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamInvite_InviteeResponseToGC) ProtoMessage() {} +func (*CMsgDOTATeamInvite_InviteeResponseToGC) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{91} +} + +const Default_CMsgDOTATeamInvite_InviteeResponseToGC_Result CMsgDOTATeamInvite_InviteeResponseToGC_Result = CMsgDOTATeamInvite_InviteeResponseToGC_JOIN + +func (m *CMsgDOTATeamInvite_InviteeResponseToGC) GetResult() CMsgDOTATeamInvite_InviteeResponseToGC_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTATeamInvite_InviteeResponseToGC_Result +} + +type CMsgDOTATeamInvite_GCResponseToInviter struct { + Result *CMsgDOTATeamInvite_GCResponseToInviter_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTATeamInvite_GCResponseToInviter_Result,def=0" json:"result,omitempty"` + InviteeName *string `protobuf:"bytes,2,opt,name=invitee_name" json:"invitee_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamInvite_GCResponseToInviter) Reset() { + *m = CMsgDOTATeamInvite_GCResponseToInviter{} +} +func (m *CMsgDOTATeamInvite_GCResponseToInviter) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamInvite_GCResponseToInviter) ProtoMessage() {} +func (*CMsgDOTATeamInvite_GCResponseToInviter) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{92} +} + +const Default_CMsgDOTATeamInvite_GCResponseToInviter_Result CMsgDOTATeamInvite_GCResponseToInviter_Result = CMsgDOTATeamInvite_GCResponseToInviter_JOINED + +func (m *CMsgDOTATeamInvite_GCResponseToInviter) GetResult() CMsgDOTATeamInvite_GCResponseToInviter_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTATeamInvite_GCResponseToInviter_Result +} + +func (m *CMsgDOTATeamInvite_GCResponseToInviter) GetInviteeName() string { + if m != nil && m.InviteeName != nil { + return *m.InviteeName + } + return "" +} + +type CMsgDOTATeamInvite_GCResponseToInvitee struct { + Result *CMsgDOTATeamInvite_GCResponseToInvitee_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTATeamInvite_GCResponseToInvitee_Result,def=0" json:"result,omitempty"` + TeamName *string `protobuf:"bytes,2,opt,name=team_name" json:"team_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamInvite_GCResponseToInvitee) Reset() { + *m = CMsgDOTATeamInvite_GCResponseToInvitee{} +} +func (m *CMsgDOTATeamInvite_GCResponseToInvitee) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamInvite_GCResponseToInvitee) ProtoMessage() {} +func (*CMsgDOTATeamInvite_GCResponseToInvitee) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{93} +} + +const Default_CMsgDOTATeamInvite_GCResponseToInvitee_Result CMsgDOTATeamInvite_GCResponseToInvitee_Result = CMsgDOTATeamInvite_GCResponseToInvitee_SUCCESS + +func (m *CMsgDOTATeamInvite_GCResponseToInvitee) GetResult() CMsgDOTATeamInvite_GCResponseToInvitee_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTATeamInvite_GCResponseToInvitee_Result +} + +func (m *CMsgDOTATeamInvite_GCResponseToInvitee) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +type CMsgDOTATeamOnProfile struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + Enabled *bool `protobuf:"varint,2,opt,name=enabled" json:"enabled,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATeamOnProfile) Reset() { *m = CMsgDOTATeamOnProfile{} } +func (m *CMsgDOTATeamOnProfile) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATeamOnProfile) ProtoMessage() {} +func (*CMsgDOTATeamOnProfile) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{94} } + +func (m *CMsgDOTATeamOnProfile) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTATeamOnProfile) GetEnabled() bool { + if m != nil && m.Enabled != nil { + return *m.Enabled + } + return false +} + +type CMsgDOTAKickTeamMember struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAKickTeamMember) Reset() { *m = CMsgDOTAKickTeamMember{} } +func (m *CMsgDOTAKickTeamMember) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAKickTeamMember) ProtoMessage() {} +func (*CMsgDOTAKickTeamMember) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{95} } + +func (m *CMsgDOTAKickTeamMember) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAKickTeamMember) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTAKickTeamMemberResponse struct { + Result *CMsgDOTAKickTeamMemberResponse_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAKickTeamMemberResponse_Result,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAKickTeamMemberResponse) Reset() { *m = CMsgDOTAKickTeamMemberResponse{} } +func (m *CMsgDOTAKickTeamMemberResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAKickTeamMemberResponse) ProtoMessage() {} +func (*CMsgDOTAKickTeamMemberResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{96} } + +const Default_CMsgDOTAKickTeamMemberResponse_Result CMsgDOTAKickTeamMemberResponse_Result = CMsgDOTAKickTeamMemberResponse_SUCCESS + +func (m *CMsgDOTAKickTeamMemberResponse) GetResult() CMsgDOTAKickTeamMemberResponse_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAKickTeamMemberResponse_Result +} + +type CMsgDOTATransferTeamAdmin struct { + NewAdminAccountId *uint32 `protobuf:"varint,1,opt,name=new_admin_account_id" json:"new_admin_account_id,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATransferTeamAdmin) Reset() { *m = CMsgDOTATransferTeamAdmin{} } +func (m *CMsgDOTATransferTeamAdmin) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATransferTeamAdmin) ProtoMessage() {} +func (*CMsgDOTATransferTeamAdmin) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{97} } + +func (m *CMsgDOTATransferTeamAdmin) GetNewAdminAccountId() uint32 { + if m != nil && m.NewAdminAccountId != nil { + return *m.NewAdminAccountId + } + return 0 +} + +func (m *CMsgDOTATransferTeamAdmin) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTATransferTeamAdminResponse struct { + Result *CMsgDOTATransferTeamAdminResponse_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTATransferTeamAdminResponse_Result,def=0" json:"result,omitempty"` + InviteeName *string `protobuf:"bytes,2,opt,name=invitee_name" json:"invitee_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATransferTeamAdminResponse) Reset() { *m = CMsgDOTATransferTeamAdminResponse{} } +func (m *CMsgDOTATransferTeamAdminResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATransferTeamAdminResponse) ProtoMessage() {} +func (*CMsgDOTATransferTeamAdminResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{98} +} + +const Default_CMsgDOTATransferTeamAdminResponse_Result CMsgDOTATransferTeamAdminResponse_Result = CMsgDOTATransferTeamAdminResponse_SUCCESS + +func (m *CMsgDOTATransferTeamAdminResponse) GetResult() CMsgDOTATransferTeamAdminResponse_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTATransferTeamAdminResponse_Result +} + +func (m *CMsgDOTATransferTeamAdminResponse) GetInviteeName() string { + if m != nil && m.InviteeName != nil { + return *m.InviteeName + } + return "" +} + +type CMsgDOTALeaveTeam struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeaveTeam) Reset() { *m = CMsgDOTALeaveTeam{} } +func (m *CMsgDOTALeaveTeam) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeaveTeam) ProtoMessage() {} +func (*CMsgDOTALeaveTeam) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{99} } + +func (m *CMsgDOTALeaveTeam) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CMsgDOTALeaveTeamResponse struct { + Result *CMsgDOTALeaveTeamResponse_Result `protobuf:"varint,1,opt,name=result,enum=CMsgDOTALeaveTeamResponse_Result,def=0" json:"result,omitempty"` + TeamName *string `protobuf:"bytes,2,opt,name=team_name" json:"team_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeaveTeamResponse) Reset() { *m = CMsgDOTALeaveTeamResponse{} } +func (m *CMsgDOTALeaveTeamResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeaveTeamResponse) ProtoMessage() {} +func (*CMsgDOTALeaveTeamResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{100} } + +const Default_CMsgDOTALeaveTeamResponse_Result CMsgDOTALeaveTeamResponse_Result = CMsgDOTALeaveTeamResponse_SUCCESS + +func (m *CMsgDOTALeaveTeamResponse) GetResult() CMsgDOTALeaveTeamResponse_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTALeaveTeamResponse_Result +} + +func (m *CMsgDOTALeaveTeamResponse) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +type CMsgDOTABetaParticipation struct { + AccessRights *uint32 `protobuf:"varint,1,opt,name=access_rights" json:"access_rights,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTABetaParticipation) Reset() { *m = CMsgDOTABetaParticipation{} } +func (m *CMsgDOTABetaParticipation) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTABetaParticipation) ProtoMessage() {} +func (*CMsgDOTABetaParticipation) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{101} } + +func (m *CMsgDOTABetaParticipation) GetAccessRights() uint32 { + if m != nil && m.AccessRights != nil { + return *m.AccessRights + } + return 0 +} + +type CMsgDOTAJoinChatChannel struct { + ChannelName *string `protobuf:"bytes,2,opt,name=channel_name" json:"channel_name,omitempty"` + ChannelType *DOTAChatChannelTypeT `protobuf:"varint,4,opt,name=channel_type,enum=DOTAChatChannelTypeT,def=0" json:"channel_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAJoinChatChannel) Reset() { *m = CMsgDOTAJoinChatChannel{} } +func (m *CMsgDOTAJoinChatChannel) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAJoinChatChannel) ProtoMessage() {} +func (*CMsgDOTAJoinChatChannel) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{102} } + +const Default_CMsgDOTAJoinChatChannel_ChannelType DOTAChatChannelTypeT = DOTAChatChannelTypeT_DOTAChannelType_Regional + +func (m *CMsgDOTAJoinChatChannel) GetChannelName() string { + if m != nil && m.ChannelName != nil { + return *m.ChannelName + } + return "" +} + +func (m *CMsgDOTAJoinChatChannel) GetChannelType() DOTAChatChannelTypeT { + if m != nil && m.ChannelType != nil { + return *m.ChannelType + } + return Default_CMsgDOTAJoinChatChannel_ChannelType +} + +type CMsgDOTALeaveChatChannel struct { + ChannelId *uint64 `protobuf:"varint,1,opt,name=channel_id" json:"channel_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeaveChatChannel) Reset() { *m = CMsgDOTALeaveChatChannel{} } +func (m *CMsgDOTALeaveChatChannel) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeaveChatChannel) ProtoMessage() {} +func (*CMsgDOTALeaveChatChannel) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{103} } + +func (m *CMsgDOTALeaveChatChannel) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +type CMsgDOTAClientIgnoredUser struct { + IgnoredAccountId *uint32 `protobuf:"varint,1,opt,name=ignored_account_id" json:"ignored_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAClientIgnoredUser) Reset() { *m = CMsgDOTAClientIgnoredUser{} } +func (m *CMsgDOTAClientIgnoredUser) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAClientIgnoredUser) ProtoMessage() {} +func (*CMsgDOTAClientIgnoredUser) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{104} } + +func (m *CMsgDOTAClientIgnoredUser) GetIgnoredAccountId() uint32 { + if m != nil && m.IgnoredAccountId != nil { + return *m.IgnoredAccountId + } + return 0 +} + +type CMsgDOTAChatMessage struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ChannelId *uint64 `protobuf:"varint,2,opt,name=channel_id" json:"channel_id,omitempty"` + PersonaName *string `protobuf:"bytes,3,opt,name=persona_name" json:"persona_name,omitempty"` + Text *string `protobuf:"bytes,4,opt,name=text" json:"text,omitempty"` + Timestamp *uint32 `protobuf:"varint,5,opt,name=timestamp" json:"timestamp,omitempty"` + SuggestInviteAccountId *uint32 `protobuf:"varint,6,opt,name=suggest_invite_account_id" json:"suggest_invite_account_id,omitempty"` + SuggestInviteName *string `protobuf:"bytes,7,opt,name=suggest_invite_name" json:"suggest_invite_name,omitempty"` + FantasyDraftOwnerAccountId *uint32 `protobuf:"varint,8,opt,name=fantasy_draft_owner_account_id" json:"fantasy_draft_owner_account_id,omitempty"` + FantasyDraftPlayerAccountId *uint32 `protobuf:"varint,9,opt,name=fantasy_draft_player_account_id" json:"fantasy_draft_player_account_id,omitempty"` + EventId *uint32 `protobuf:"varint,10,opt,name=event_id" json:"event_id,omitempty"` + SuggestInviteToLobby *bool `protobuf:"varint,11,opt,name=suggest_invite_to_lobby" json:"suggest_invite_to_lobby,omitempty"` + EventPoints *uint32 `protobuf:"varint,12,opt,name=event_points" json:"event_points,omitempty"` + CoinFlip *bool `protobuf:"varint,13,opt,name=coin_flip" json:"coin_flip,omitempty"` + PlayerId *int32 `protobuf:"varint,14,opt,name=player_id,def=-1" json:"player_id,omitempty"` + ShareProfileAccountId *uint32 `protobuf:"varint,15,opt,name=share_profile_account_id" json:"share_profile_account_id,omitempty"` + ChannelUserId *uint32 `protobuf:"varint,16,opt,name=channel_user_id" json:"channel_user_id,omitempty"` + DiceRoll *CMsgDOTAChatMessage_DiceRoll `protobuf:"bytes,17,opt,name=dice_roll" json:"dice_roll,omitempty"` + SharePartyId *uint64 `protobuf:"varint,18,opt,name=share_party_id" json:"share_party_id,omitempty"` + ShareLobbyId *uint64 `protobuf:"varint,19,opt,name=share_lobby_id" json:"share_lobby_id,omitempty"` + ShareLobbyCustomGameId *uint64 `protobuf:"varint,20,opt,name=share_lobby_custom_game_id" json:"share_lobby_custom_game_id,omitempty"` + ShareLobbyPasskey *string `protobuf:"bytes,21,opt,name=share_lobby_passkey" json:"share_lobby_passkey,omitempty"` + PrivateChatChannelId *uint32 `protobuf:"varint,22,opt,name=private_chat_channel_id" json:"private_chat_channel_id,omitempty"` + Status *uint32 `protobuf:"varint,23,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatMessage) Reset() { *m = CMsgDOTAChatMessage{} } +func (m *CMsgDOTAChatMessage) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatMessage) ProtoMessage() {} +func (*CMsgDOTAChatMessage) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{105} } + +const Default_CMsgDOTAChatMessage_PlayerId int32 = -1 + +func (m *CMsgDOTAChatMessage) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgDOTAChatMessage) GetText() string { + if m != nil && m.Text != nil { + return *m.Text + } + return "" +} + +func (m *CMsgDOTAChatMessage) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetSuggestInviteAccountId() uint32 { + if m != nil && m.SuggestInviteAccountId != nil { + return *m.SuggestInviteAccountId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetSuggestInviteName() string { + if m != nil && m.SuggestInviteName != nil { + return *m.SuggestInviteName + } + return "" +} + +func (m *CMsgDOTAChatMessage) GetFantasyDraftOwnerAccountId() uint32 { + if m != nil && m.FantasyDraftOwnerAccountId != nil { + return *m.FantasyDraftOwnerAccountId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetFantasyDraftPlayerAccountId() uint32 { + if m != nil && m.FantasyDraftPlayerAccountId != nil { + return *m.FantasyDraftPlayerAccountId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetSuggestInviteToLobby() bool { + if m != nil && m.SuggestInviteToLobby != nil { + return *m.SuggestInviteToLobby + } + return false +} + +func (m *CMsgDOTAChatMessage) GetEventPoints() uint32 { + if m != nil && m.EventPoints != nil { + return *m.EventPoints + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetCoinFlip() bool { + if m != nil && m.CoinFlip != nil { + return *m.CoinFlip + } + return false +} + +func (m *CMsgDOTAChatMessage) GetPlayerId() int32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return Default_CMsgDOTAChatMessage_PlayerId +} + +func (m *CMsgDOTAChatMessage) GetShareProfileAccountId() uint32 { + if m != nil && m.ShareProfileAccountId != nil { + return *m.ShareProfileAccountId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetChannelUserId() uint32 { + if m != nil && m.ChannelUserId != nil { + return *m.ChannelUserId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetDiceRoll() *CMsgDOTAChatMessage_DiceRoll { + if m != nil { + return m.DiceRoll + } + return nil +} + +func (m *CMsgDOTAChatMessage) GetSharePartyId() uint64 { + if m != nil && m.SharePartyId != nil { + return *m.SharePartyId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetShareLobbyId() uint64 { + if m != nil && m.ShareLobbyId != nil { + return *m.ShareLobbyId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetShareLobbyCustomGameId() uint64 { + if m != nil && m.ShareLobbyCustomGameId != nil { + return *m.ShareLobbyCustomGameId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetShareLobbyPasskey() string { + if m != nil && m.ShareLobbyPasskey != nil { + return *m.ShareLobbyPasskey + } + return "" +} + +func (m *CMsgDOTAChatMessage) GetPrivateChatChannelId() uint32 { + if m != nil && m.PrivateChatChannelId != nil { + return *m.PrivateChatChannelId + } + return 0 +} + +func (m *CMsgDOTAChatMessage) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CMsgDOTAChatMessage_DiceRoll struct { + RollMin *int32 `protobuf:"varint,1,opt,name=roll_min" json:"roll_min,omitempty"` + RollMax *int32 `protobuf:"varint,2,opt,name=roll_max" json:"roll_max,omitempty"` + Result *int32 `protobuf:"varint,3,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatMessage_DiceRoll) Reset() { *m = CMsgDOTAChatMessage_DiceRoll{} } +func (m *CMsgDOTAChatMessage_DiceRoll) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatMessage_DiceRoll) ProtoMessage() {} +func (*CMsgDOTAChatMessage_DiceRoll) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{105, 0} +} + +func (m *CMsgDOTAChatMessage_DiceRoll) GetRollMin() int32 { + if m != nil && m.RollMin != nil { + return *m.RollMin + } + return 0 +} + +func (m *CMsgDOTAChatMessage_DiceRoll) GetRollMax() int32 { + if m != nil && m.RollMax != nil { + return *m.RollMax + } + return 0 +} + +func (m *CMsgDOTAChatMessage_DiceRoll) GetResult() int32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgDOTAChatMember struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + PersonaName *string `protobuf:"bytes,2,opt,name=persona_name" json:"persona_name,omitempty"` + ChannelUserId *uint32 `protobuf:"varint,3,opt,name=channel_user_id" json:"channel_user_id,omitempty"` + Status *uint32 `protobuf:"varint,4,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatMember) Reset() { *m = CMsgDOTAChatMember{} } +func (m *CMsgDOTAChatMember) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatMember) ProtoMessage() {} +func (*CMsgDOTAChatMember) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{106} } + +func (m *CMsgDOTAChatMember) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTAChatMember) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgDOTAChatMember) GetChannelUserId() uint32 { + if m != nil && m.ChannelUserId != nil { + return *m.ChannelUserId + } + return 0 +} + +func (m *CMsgDOTAChatMember) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CMsgDOTAJoinChatChannelResponse struct { + Response *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"` + ChannelName *string `protobuf:"bytes,2,opt,name=channel_name" json:"channel_name,omitempty"` + ChannelId *uint64 `protobuf:"fixed64,3,opt,name=channel_id" json:"channel_id,omitempty"` + MaxMembers *uint32 `protobuf:"varint,4,opt,name=max_members" json:"max_members,omitempty"` + Members []*CMsgDOTAChatMember `protobuf:"bytes,5,rep,name=members" json:"members,omitempty"` + ChannelType *DOTAChatChannelTypeT `protobuf:"varint,6,opt,name=channel_type,enum=DOTAChatChannelTypeT,def=0" json:"channel_type,omitempty"` + Result *CMsgDOTAJoinChatChannelResponse_Result `protobuf:"varint,7,opt,name=result,enum=CMsgDOTAJoinChatChannelResponse_Result,def=0" json:"result,omitempty"` + GcInitiatedJoin *bool `protobuf:"varint,8,opt,name=gc_initiated_join" json:"gc_initiated_join,omitempty"` + ChannelUserId *uint32 `protobuf:"varint,9,opt,name=channel_user_id" json:"channel_user_id,omitempty"` + WelcomeMessage *string `protobuf:"bytes,10,opt,name=welcome_message" json:"welcome_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAJoinChatChannelResponse) Reset() { *m = CMsgDOTAJoinChatChannelResponse{} } +func (m *CMsgDOTAJoinChatChannelResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAJoinChatChannelResponse) ProtoMessage() {} +func (*CMsgDOTAJoinChatChannelResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{107} +} + +const Default_CMsgDOTAJoinChatChannelResponse_ChannelType DOTAChatChannelTypeT = DOTAChatChannelTypeT_DOTAChannelType_Regional +const Default_CMsgDOTAJoinChatChannelResponse_Result CMsgDOTAJoinChatChannelResponse_Result = CMsgDOTAJoinChatChannelResponse_JOIN_SUCCESS + +func (m *CMsgDOTAJoinChatChannelResponse) GetResponse() uint32 { + if m != nil && m.Response != nil { + return *m.Response + } + return 0 +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetChannelName() string { + if m != nil && m.ChannelName != nil { + return *m.ChannelName + } + return "" +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetMaxMembers() uint32 { + if m != nil && m.MaxMembers != nil { + return *m.MaxMembers + } + return 0 +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetMembers() []*CMsgDOTAChatMember { + if m != nil { + return m.Members + } + return nil +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetChannelType() DOTAChatChannelTypeT { + if m != nil && m.ChannelType != nil { + return *m.ChannelType + } + return Default_CMsgDOTAJoinChatChannelResponse_ChannelType +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetResult() CMsgDOTAJoinChatChannelResponse_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAJoinChatChannelResponse_Result +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetGcInitiatedJoin() bool { + if m != nil && m.GcInitiatedJoin != nil { + return *m.GcInitiatedJoin + } + return false +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetChannelUserId() uint32 { + if m != nil && m.ChannelUserId != nil { + return *m.ChannelUserId + } + return 0 +} + +func (m *CMsgDOTAJoinChatChannelResponse) GetWelcomeMessage() string { + if m != nil && m.WelcomeMessage != nil { + return *m.WelcomeMessage + } + return "" +} + +type CMsgDOTAChatChannelFullUpdate struct { + ChannelId *uint64 `protobuf:"fixed64,1,opt,name=channel_id" json:"channel_id,omitempty"` + Members []*CMsgDOTAChatMember `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatChannelFullUpdate) Reset() { *m = CMsgDOTAChatChannelFullUpdate{} } +func (m *CMsgDOTAChatChannelFullUpdate) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatChannelFullUpdate) ProtoMessage() {} +func (*CMsgDOTAChatChannelFullUpdate) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{108} } + +func (m *CMsgDOTAChatChannelFullUpdate) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgDOTAChatChannelFullUpdate) GetMembers() []*CMsgDOTAChatMember { + if m != nil { + return m.Members + } + return nil +} + +type CMsgDOTAOtherJoinedChatChannel struct { + ChannelId *uint64 `protobuf:"fixed64,1,opt,name=channel_id" json:"channel_id,omitempty"` + PersonaName *string `protobuf:"bytes,2,opt,name=persona_name" json:"persona_name,omitempty"` + SteamId *uint64 `protobuf:"fixed64,3,opt,name=steam_id" json:"steam_id,omitempty"` + ChannelUserId *uint32 `protobuf:"varint,4,opt,name=channel_user_id" json:"channel_user_id,omitempty"` + Status *uint32 `protobuf:"varint,5,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAOtherJoinedChatChannel) Reset() { *m = CMsgDOTAOtherJoinedChatChannel{} } +func (m *CMsgDOTAOtherJoinedChatChannel) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAOtherJoinedChatChannel) ProtoMessage() {} +func (*CMsgDOTAOtherJoinedChatChannel) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{109} +} + +func (m *CMsgDOTAOtherJoinedChatChannel) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgDOTAOtherJoinedChatChannel) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgDOTAOtherJoinedChatChannel) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTAOtherJoinedChatChannel) GetChannelUserId() uint32 { + if m != nil && m.ChannelUserId != nil { + return *m.ChannelUserId + } + return 0 +} + +func (m *CMsgDOTAOtherJoinedChatChannel) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CMsgDOTAOtherLeftChatChannel struct { + ChannelId *uint64 `protobuf:"fixed64,1,opt,name=channel_id" json:"channel_id,omitempty"` + SteamId *uint64 `protobuf:"fixed64,2,opt,name=steam_id" json:"steam_id,omitempty"` + ChannelUserId *uint32 `protobuf:"varint,3,opt,name=channel_user_id" json:"channel_user_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAOtherLeftChatChannel) Reset() { *m = CMsgDOTAOtherLeftChatChannel{} } +func (m *CMsgDOTAOtherLeftChatChannel) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAOtherLeftChatChannel) ProtoMessage() {} +func (*CMsgDOTAOtherLeftChatChannel) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{110} } + +func (m *CMsgDOTAOtherLeftChatChannel) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgDOTAOtherLeftChatChannel) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTAOtherLeftChatChannel) GetChannelUserId() uint32 { + if m != nil && m.ChannelUserId != nil { + return *m.ChannelUserId + } + return 0 +} + +type CMsgDOTAChatChannelMemberUpdate struct { + ChannelId *uint64 `protobuf:"fixed64,1,opt,name=channel_id" json:"channel_id,omitempty"` + LeftSteamIds []uint64 `protobuf:"fixed64,2,rep,name=left_steam_ids" json:"left_steam_ids,omitempty"` + JoinedMembers []*CMsgDOTAChatChannelMemberUpdate_JoinedMember `protobuf:"bytes,3,rep,name=joined_members" json:"joined_members,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatChannelMemberUpdate) Reset() { *m = CMsgDOTAChatChannelMemberUpdate{} } +func (m *CMsgDOTAChatChannelMemberUpdate) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatChannelMemberUpdate) ProtoMessage() {} +func (*CMsgDOTAChatChannelMemberUpdate) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{111} +} + +func (m *CMsgDOTAChatChannelMemberUpdate) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgDOTAChatChannelMemberUpdate) GetLeftSteamIds() []uint64 { + if m != nil { + return m.LeftSteamIds + } + return nil +} + +func (m *CMsgDOTAChatChannelMemberUpdate) GetJoinedMembers() []*CMsgDOTAChatChannelMemberUpdate_JoinedMember { + if m != nil { + return m.JoinedMembers + } + return nil +} + +type CMsgDOTAChatChannelMemberUpdate_JoinedMember struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + PersonaName *string `protobuf:"bytes,2,opt,name=persona_name" json:"persona_name,omitempty"` + ChannelUserId *uint32 `protobuf:"varint,3,opt,name=channel_user_id" json:"channel_user_id,omitempty"` + Status *uint32 `protobuf:"varint,4,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatChannelMemberUpdate_JoinedMember) Reset() { + *m = CMsgDOTAChatChannelMemberUpdate_JoinedMember{} +} +func (m *CMsgDOTAChatChannelMemberUpdate_JoinedMember) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAChatChannelMemberUpdate_JoinedMember) ProtoMessage() {} +func (*CMsgDOTAChatChannelMemberUpdate_JoinedMember) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{111, 0} +} + +func (m *CMsgDOTAChatChannelMemberUpdate_JoinedMember) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTAChatChannelMemberUpdate_JoinedMember) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgDOTAChatChannelMemberUpdate_JoinedMember) GetChannelUserId() uint32 { + if m != nil && m.ChannelUserId != nil { + return *m.ChannelUserId + } + return 0 +} + +func (m *CMsgDOTAChatChannelMemberUpdate_JoinedMember) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CMsgDOTARequestChatChannelList struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestChatChannelList) Reset() { *m = CMsgDOTARequestChatChannelList{} } +func (m *CMsgDOTARequestChatChannelList) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestChatChannelList) ProtoMessage() {} +func (*CMsgDOTARequestChatChannelList) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{112} +} + +type CMsgDOTARequestChatChannelListResponse struct { + Channels []*CMsgDOTARequestChatChannelListResponse_ChatChannel `protobuf:"bytes,1,rep,name=channels" json:"channels,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestChatChannelListResponse) Reset() { + *m = CMsgDOTARequestChatChannelListResponse{} +} +func (m *CMsgDOTARequestChatChannelListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestChatChannelListResponse) ProtoMessage() {} +func (*CMsgDOTARequestChatChannelListResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{113} +} + +func (m *CMsgDOTARequestChatChannelListResponse) GetChannels() []*CMsgDOTARequestChatChannelListResponse_ChatChannel { + if m != nil { + return m.Channels + } + return nil +} + +type CMsgDOTARequestChatChannelListResponse_ChatChannel struct { + ChannelName *string `protobuf:"bytes,1,opt,name=channel_name" json:"channel_name,omitempty"` + NumMembers *uint32 `protobuf:"varint,2,opt,name=num_members" json:"num_members,omitempty"` + ChannelType *DOTAChatChannelTypeT `protobuf:"varint,3,opt,name=channel_type,enum=DOTAChatChannelTypeT,def=0" json:"channel_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestChatChannelListResponse_ChatChannel) Reset() { + *m = CMsgDOTARequestChatChannelListResponse_ChatChannel{} +} +func (m *CMsgDOTARequestChatChannelListResponse_ChatChannel) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARequestChatChannelListResponse_ChatChannel) ProtoMessage() {} +func (*CMsgDOTARequestChatChannelListResponse_ChatChannel) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{113, 0} +} + +const Default_CMsgDOTARequestChatChannelListResponse_ChatChannel_ChannelType DOTAChatChannelTypeT = DOTAChatChannelTypeT_DOTAChannelType_Regional + +func (m *CMsgDOTARequestChatChannelListResponse_ChatChannel) GetChannelName() string { + if m != nil && m.ChannelName != nil { + return *m.ChannelName + } + return "" +} + +func (m *CMsgDOTARequestChatChannelListResponse_ChatChannel) GetNumMembers() uint32 { + if m != nil && m.NumMembers != nil { + return *m.NumMembers + } + return 0 +} + +func (m *CMsgDOTARequestChatChannelListResponse_ChatChannel) GetChannelType() DOTAChatChannelTypeT { + if m != nil && m.ChannelType != nil { + return *m.ChannelType + } + return Default_CMsgDOTARequestChatChannelListResponse_ChatChannel_ChannelType +} + +type CMsgDOTAChatGetUserList struct { + ChannelId *uint64 `protobuf:"fixed64,1,opt,name=channel_id" json:"channel_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatGetUserList) Reset() { *m = CMsgDOTAChatGetUserList{} } +func (m *CMsgDOTAChatGetUserList) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatGetUserList) ProtoMessage() {} +func (*CMsgDOTAChatGetUserList) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{114} } + +func (m *CMsgDOTAChatGetUserList) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +type CMsgDOTAChatGetUserListResponse struct { + ChannelId *uint64 `protobuf:"fixed64,1,opt,name=channel_id" json:"channel_id,omitempty"` + Members []*CMsgDOTAChatGetUserListResponse_Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatGetUserListResponse) Reset() { *m = CMsgDOTAChatGetUserListResponse{} } +func (m *CMsgDOTAChatGetUserListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatGetUserListResponse) ProtoMessage() {} +func (*CMsgDOTAChatGetUserListResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{115} +} + +func (m *CMsgDOTAChatGetUserListResponse) GetChannelId() uint64 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgDOTAChatGetUserListResponse) GetMembers() []*CMsgDOTAChatGetUserListResponse_Member { + if m != nil { + return m.Members + } + return nil +} + +type CMsgDOTAChatGetUserListResponse_Member struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + PersonaName *string `protobuf:"bytes,2,opt,name=persona_name" json:"persona_name,omitempty"` + ChannelUserId *uint32 `protobuf:"varint,3,opt,name=channel_user_id" json:"channel_user_id,omitempty"` + Status *uint32 `protobuf:"varint,4,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatGetUserListResponse_Member) Reset() { + *m = CMsgDOTAChatGetUserListResponse_Member{} +} +func (m *CMsgDOTAChatGetUserListResponse_Member) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatGetUserListResponse_Member) ProtoMessage() {} +func (*CMsgDOTAChatGetUserListResponse_Member) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{115, 0} +} + +func (m *CMsgDOTAChatGetUserListResponse_Member) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTAChatGetUserListResponse_Member) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgDOTAChatGetUserListResponse_Member) GetChannelUserId() uint32 { + if m != nil && m.ChannelUserId != nil { + return *m.ChannelUserId + } + return 0 +} + +func (m *CMsgDOTAChatGetUserListResponse_Member) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CMsgDOTAChatGetMemberCount struct { + ChannelName *string `protobuf:"bytes,1,opt,name=channel_name" json:"channel_name,omitempty"` + ChannelType *DOTAChatChannelTypeT `protobuf:"varint,2,opt,name=channel_type,enum=DOTAChatChannelTypeT,def=0" json:"channel_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatGetMemberCount) Reset() { *m = CMsgDOTAChatGetMemberCount{} } +func (m *CMsgDOTAChatGetMemberCount) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatGetMemberCount) ProtoMessage() {} +func (*CMsgDOTAChatGetMemberCount) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{116} } + +const Default_CMsgDOTAChatGetMemberCount_ChannelType DOTAChatChannelTypeT = DOTAChatChannelTypeT_DOTAChannelType_Regional + +func (m *CMsgDOTAChatGetMemberCount) GetChannelName() string { + if m != nil && m.ChannelName != nil { + return *m.ChannelName + } + return "" +} + +func (m *CMsgDOTAChatGetMemberCount) GetChannelType() DOTAChatChannelTypeT { + if m != nil && m.ChannelType != nil { + return *m.ChannelType + } + return Default_CMsgDOTAChatGetMemberCount_ChannelType +} + +type CMsgDOTAChatGetMemberCountResponse struct { + ChannelName *string `protobuf:"bytes,1,opt,name=channel_name" json:"channel_name,omitempty"` + ChannelType *DOTAChatChannelTypeT `protobuf:"varint,2,opt,name=channel_type,enum=DOTAChatChannelTypeT,def=0" json:"channel_type,omitempty"` + MemberCount *uint32 `protobuf:"varint,3,opt,name=member_count" json:"member_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatGetMemberCountResponse) Reset() { *m = CMsgDOTAChatGetMemberCountResponse{} } +func (m *CMsgDOTAChatGetMemberCountResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatGetMemberCountResponse) ProtoMessage() {} +func (*CMsgDOTAChatGetMemberCountResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{117} +} + +const Default_CMsgDOTAChatGetMemberCountResponse_ChannelType DOTAChatChannelTypeT = DOTAChatChannelTypeT_DOTAChannelType_Regional + +func (m *CMsgDOTAChatGetMemberCountResponse) GetChannelName() string { + if m != nil && m.ChannelName != nil { + return *m.ChannelName + } + return "" +} + +func (m *CMsgDOTAChatGetMemberCountResponse) GetChannelType() DOTAChatChannelTypeT { + if m != nil && m.ChannelType != nil { + return *m.ChannelType + } + return Default_CMsgDOTAChatGetMemberCountResponse_ChannelType +} + +func (m *CMsgDOTAChatGetMemberCountResponse) GetMemberCount() uint32 { + if m != nil && m.MemberCount != nil { + return *m.MemberCount + } + return 0 +} + +type CMsgDOTAChatRegionsEnabled struct { + EnableAllRegions *bool `protobuf:"varint,1,opt,name=enable_all_regions" json:"enable_all_regions,omitempty"` + EnabledRegions []*CMsgDOTAChatRegionsEnabled_Region `protobuf:"bytes,2,rep,name=enabled_regions" json:"enabled_regions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatRegionsEnabled) Reset() { *m = CMsgDOTAChatRegionsEnabled{} } +func (m *CMsgDOTAChatRegionsEnabled) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatRegionsEnabled) ProtoMessage() {} +func (*CMsgDOTAChatRegionsEnabled) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{118} } + +func (m *CMsgDOTAChatRegionsEnabled) GetEnableAllRegions() bool { + if m != nil && m.EnableAllRegions != nil { + return *m.EnableAllRegions + } + return false +} + +func (m *CMsgDOTAChatRegionsEnabled) GetEnabledRegions() []*CMsgDOTAChatRegionsEnabled_Region { + if m != nil { + return m.EnabledRegions + } + return nil +} + +type CMsgDOTAChatRegionsEnabled_Region struct { + MinLatitude *float32 `protobuf:"fixed32,1,opt,name=min_latitude" json:"min_latitude,omitempty"` + MaxLatitude *float32 `protobuf:"fixed32,2,opt,name=max_latitude" json:"max_latitude,omitempty"` + MinLongitude *float32 `protobuf:"fixed32,3,opt,name=min_longitude" json:"min_longitude,omitempty"` + MaxLongitude *float32 `protobuf:"fixed32,4,opt,name=max_longitude" json:"max_longitude,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAChatRegionsEnabled_Region) Reset() { *m = CMsgDOTAChatRegionsEnabled_Region{} } +func (m *CMsgDOTAChatRegionsEnabled_Region) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAChatRegionsEnabled_Region) ProtoMessage() {} +func (*CMsgDOTAChatRegionsEnabled_Region) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{118, 0} +} + +func (m *CMsgDOTAChatRegionsEnabled_Region) GetMinLatitude() float32 { + if m != nil && m.MinLatitude != nil { + return *m.MinLatitude + } + return 0 +} + +func (m *CMsgDOTAChatRegionsEnabled_Region) GetMaxLatitude() float32 { + if m != nil && m.MaxLatitude != nil { + return *m.MaxLatitude + } + return 0 +} + +func (m *CMsgDOTAChatRegionsEnabled_Region) GetMinLongitude() float32 { + if m != nil && m.MinLongitude != nil { + return *m.MinLongitude + } + return 0 +} + +func (m *CMsgDOTAChatRegionsEnabled_Region) GetMaxLongitude() float32 { + if m != nil && m.MaxLongitude != nil { + return *m.MaxLongitude + } + return 0 +} + +type CMsgDOTAGuildSDO struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Tag *string `protobuf:"bytes,3,opt,name=tag" json:"tag,omitempty"` + TimeCreated *uint32 `protobuf:"varint,4,opt,name=time_created" json:"time_created,omitempty"` + TimeDisbanded *uint32 `protobuf:"varint,5,opt,name=time_disbanded" json:"time_disbanded,omitempty"` + Logo *uint64 `protobuf:"varint,6,opt,name=logo" json:"logo,omitempty"` + BaseLogo *uint64 `protobuf:"varint,7,opt,name=base_logo" json:"base_logo,omitempty"` + BannerLogo *uint64 `protobuf:"varint,8,opt,name=banner_logo" json:"banner_logo,omitempty"` + Members []*CMsgDOTAGuildSDO_Member `protobuf:"bytes,9,rep,name=members" json:"members,omitempty"` + Invitations []*CMsgDOTAGuildSDO_Invitation `protobuf:"bytes,10,rep,name=invitations" json:"invitations,omitempty"` + Message *string `protobuf:"bytes,11,opt,name=message" json:"message,omitempty"` + Incremental *bool `protobuf:"varint,12,opt,name=incremental" json:"incremental,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildSDO) Reset() { *m = CMsgDOTAGuildSDO{} } +func (m *CMsgDOTAGuildSDO) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildSDO) ProtoMessage() {} +func (*CMsgDOTAGuildSDO) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{119} } + +func (m *CMsgDOTAGuildSDO) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildSDO) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTAGuildSDO) GetTag() string { + if m != nil && m.Tag != nil { + return *m.Tag + } + return "" +} + +func (m *CMsgDOTAGuildSDO) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *CMsgDOTAGuildSDO) GetTimeDisbanded() uint32 { + if m != nil && m.TimeDisbanded != nil { + return *m.TimeDisbanded + } + return 0 +} + +func (m *CMsgDOTAGuildSDO) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAGuildSDO) GetBaseLogo() uint64 { + if m != nil && m.BaseLogo != nil { + return *m.BaseLogo + } + return 0 +} + +func (m *CMsgDOTAGuildSDO) GetBannerLogo() uint64 { + if m != nil && m.BannerLogo != nil { + return *m.BannerLogo + } + return 0 +} + +func (m *CMsgDOTAGuildSDO) GetMembers() []*CMsgDOTAGuildSDO_Member { + if m != nil { + return m.Members + } + return nil +} + +func (m *CMsgDOTAGuildSDO) GetInvitations() []*CMsgDOTAGuildSDO_Invitation { + if m != nil { + return m.Invitations + } + return nil +} + +func (m *CMsgDOTAGuildSDO) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgDOTAGuildSDO) GetIncremental() bool { + if m != nil && m.Incremental != nil { + return *m.Incremental + } + return false +} + +type CMsgDOTAGuildSDO_Member struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + TimeJoined *uint32 `protobuf:"varint,2,opt,name=time_joined" json:"time_joined,omitempty"` + Role *uint32 `protobuf:"varint,3,opt,name=role" json:"role,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildSDO_Member) Reset() { *m = CMsgDOTAGuildSDO_Member{} } +func (m *CMsgDOTAGuildSDO_Member) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildSDO_Member) ProtoMessage() {} +func (*CMsgDOTAGuildSDO_Member) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{119, 0} } + +func (m *CMsgDOTAGuildSDO_Member) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAGuildSDO_Member) GetTimeJoined() uint32 { + if m != nil && m.TimeJoined != nil { + return *m.TimeJoined + } + return 0 +} + +func (m *CMsgDOTAGuildSDO_Member) GetRole() uint32 { + if m != nil && m.Role != nil { + return *m.Role + } + return 0 +} + +type CMsgDOTAGuildSDO_Invitation struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + TimeSent *uint32 `protobuf:"varint,2,opt,name=time_sent" json:"time_sent,omitempty"` + AccountIdSender *uint32 `protobuf:"varint,3,opt,name=account_id_sender" json:"account_id_sender,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildSDO_Invitation) Reset() { *m = CMsgDOTAGuildSDO_Invitation{} } +func (m *CMsgDOTAGuildSDO_Invitation) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildSDO_Invitation) ProtoMessage() {} +func (*CMsgDOTAGuildSDO_Invitation) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{119, 1} +} + +func (m *CMsgDOTAGuildSDO_Invitation) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAGuildSDO_Invitation) GetTimeSent() uint32 { + if m != nil && m.TimeSent != nil { + return *m.TimeSent + } + return 0 +} + +func (m *CMsgDOTAGuildSDO_Invitation) GetAccountIdSender() uint32 { + if m != nil && m.AccountIdSender != nil { + return *m.AccountIdSender + } + return 0 +} + +type CMsgDOTAGuildAuditSDO struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Entries []*CMsgDOTAGuildAuditSDO_Entry `protobuf:"bytes,2,rep,name=entries" json:"entries,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildAuditSDO) Reset() { *m = CMsgDOTAGuildAuditSDO{} } +func (m *CMsgDOTAGuildAuditSDO) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildAuditSDO) ProtoMessage() {} +func (*CMsgDOTAGuildAuditSDO) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{120} } + +func (m *CMsgDOTAGuildAuditSDO) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildAuditSDO) GetEntries() []*CMsgDOTAGuildAuditSDO_Entry { + if m != nil { + return m.Entries + } + return nil +} + +type CMsgDOTAGuildAuditSDO_Entry struct { + EventIndex *uint32 `protobuf:"varint,1,opt,name=event_index" json:"event_index,omitempty"` + Timestamp *uint32 `protobuf:"varint,2,opt,name=timestamp" json:"timestamp,omitempty"` + Action *uint32 `protobuf:"varint,3,opt,name=action" json:"action,omitempty"` + AccountIdRequestor *uint32 `protobuf:"varint,4,opt,name=account_id_requestor" json:"account_id_requestor,omitempty"` + AccountIdTarget *uint32 `protobuf:"varint,5,opt,name=account_id_target" json:"account_id_target,omitempty"` + ReferenceDataA *uint32 `protobuf:"varint,6,opt,name=reference_data_a" json:"reference_data_a,omitempty"` + ReferenceDataB *uint32 `protobuf:"varint,7,opt,name=reference_data_b" json:"reference_data_b,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) Reset() { *m = CMsgDOTAGuildAuditSDO_Entry{} } +func (m *CMsgDOTAGuildAuditSDO_Entry) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildAuditSDO_Entry) ProtoMessage() {} +func (*CMsgDOTAGuildAuditSDO_Entry) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{120, 0} +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) GetEventIndex() uint32 { + if m != nil && m.EventIndex != nil { + return *m.EventIndex + } + return 0 +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) GetAction() uint32 { + if m != nil && m.Action != nil { + return *m.Action + } + return 0 +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) GetAccountIdRequestor() uint32 { + if m != nil && m.AccountIdRequestor != nil { + return *m.AccountIdRequestor + } + return 0 +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) GetAccountIdTarget() uint32 { + if m != nil && m.AccountIdTarget != nil { + return *m.AccountIdTarget + } + return 0 +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) GetReferenceDataA() uint32 { + if m != nil && m.ReferenceDataA != nil { + return *m.ReferenceDataA + } + return 0 +} + +func (m *CMsgDOTAGuildAuditSDO_Entry) GetReferenceDataB() uint32 { + if m != nil && m.ReferenceDataB != nil { + return *m.ReferenceDataB + } + return 0 +} + +type CMsgDOTAAccountGuildMembershipsSDO struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Memberships []*CMsgDOTAAccountGuildMembershipsSDO_Membership `protobuf:"bytes,2,rep,name=memberships" json:"memberships,omitempty"` + Invitations []*CMsgDOTAAccountGuildMembershipsSDO_Invitation `protobuf:"bytes,3,rep,name=invitations" json:"invitations,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO) Reset() { *m = CMsgDOTAAccountGuildMembershipsSDO{} } +func (m *CMsgDOTAAccountGuildMembershipsSDO) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAAccountGuildMembershipsSDO) ProtoMessage() {} +func (*CMsgDOTAAccountGuildMembershipsSDO) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{121} +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO) GetMemberships() []*CMsgDOTAAccountGuildMembershipsSDO_Membership { + if m != nil { + return m.Memberships + } + return nil +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO) GetInvitations() []*CMsgDOTAAccountGuildMembershipsSDO_Invitation { + if m != nil { + return m.Invitations + } + return nil +} + +type CMsgDOTAAccountGuildMembershipsSDO_Membership struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Role *uint32 `protobuf:"varint,2,opt,name=role" json:"role,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO_Membership) Reset() { + *m = CMsgDOTAAccountGuildMembershipsSDO_Membership{} +} +func (m *CMsgDOTAAccountGuildMembershipsSDO_Membership) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAAccountGuildMembershipsSDO_Membership) ProtoMessage() {} +func (*CMsgDOTAAccountGuildMembershipsSDO_Membership) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{121, 0} +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO_Membership) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO_Membership) GetRole() uint32 { + if m != nil && m.Role != nil { + return *m.Role + } + return 0 +} + +type CMsgDOTAAccountGuildMembershipsSDO_Invitation struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + TimeSent *uint32 `protobuf:"varint,2,opt,name=time_sent" json:"time_sent,omitempty"` + AccountIdSender *uint32 `protobuf:"varint,3,opt,name=account_id_sender" json:"account_id_sender,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO_Invitation) Reset() { + *m = CMsgDOTAAccountGuildMembershipsSDO_Invitation{} +} +func (m *CMsgDOTAAccountGuildMembershipsSDO_Invitation) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAAccountGuildMembershipsSDO_Invitation) ProtoMessage() {} +func (*CMsgDOTAAccountGuildMembershipsSDO_Invitation) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{121, 1} +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO_Invitation) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO_Invitation) GetTimeSent() uint32 { + if m != nil && m.TimeSent != nil { + return *m.TimeSent + } + return 0 +} + +func (m *CMsgDOTAAccountGuildMembershipsSDO_Invitation) GetAccountIdSender() uint32 { + if m != nil && m.AccountIdSender != nil { + return *m.AccountIdSender + } + return 0 +} + +type CMsgDOTAGuildCreateRequest struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Tag *string `protobuf:"bytes,2,opt,name=tag" json:"tag,omitempty"` + Logo *uint64 `protobuf:"varint,3,opt,name=logo" json:"logo,omitempty"` + BaseLogo *uint64 `protobuf:"varint,4,opt,name=base_logo" json:"base_logo,omitempty"` + BannerLogo *uint64 `protobuf:"varint,5,opt,name=banner_logo" json:"banner_logo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildCreateRequest) Reset() { *m = CMsgDOTAGuildCreateRequest{} } +func (m *CMsgDOTAGuildCreateRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildCreateRequest) ProtoMessage() {} +func (*CMsgDOTAGuildCreateRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{122} } + +func (m *CMsgDOTAGuildCreateRequest) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTAGuildCreateRequest) GetTag() string { + if m != nil && m.Tag != nil { + return *m.Tag + } + return "" +} + +func (m *CMsgDOTAGuildCreateRequest) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAGuildCreateRequest) GetBaseLogo() uint64 { + if m != nil && m.BaseLogo != nil { + return *m.BaseLogo + } + return 0 +} + +func (m *CMsgDOTAGuildCreateRequest) GetBannerLogo() uint64 { + if m != nil && m.BannerLogo != nil { + return *m.BannerLogo + } + return 0 +} + +type CMsgDOTAGuildCreateResponse struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Errors []CMsgDOTAGuildCreateResponse_EError `protobuf:"varint,2,rep,name=errors,enum=CMsgDOTAGuildCreateResponse_EError" json:"errors,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildCreateResponse) Reset() { *m = CMsgDOTAGuildCreateResponse{} } +func (m *CMsgDOTAGuildCreateResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildCreateResponse) ProtoMessage() {} +func (*CMsgDOTAGuildCreateResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{123} } + +func (m *CMsgDOTAGuildCreateResponse) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildCreateResponse) GetErrors() []CMsgDOTAGuildCreateResponse_EError { + if m != nil { + return m.Errors + } + return nil +} + +type CMsgDOTAGuildSetAccountRoleRequest struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + TargetAccountId *uint32 `protobuf:"varint,2,opt,name=target_account_id" json:"target_account_id,omitempty"` + TargetRole *uint32 `protobuf:"varint,3,opt,name=target_role" json:"target_role,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildSetAccountRoleRequest) Reset() { *m = CMsgDOTAGuildSetAccountRoleRequest{} } +func (m *CMsgDOTAGuildSetAccountRoleRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildSetAccountRoleRequest) ProtoMessage() {} +func (*CMsgDOTAGuildSetAccountRoleRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{124} +} + +func (m *CMsgDOTAGuildSetAccountRoleRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildSetAccountRoleRequest) GetTargetAccountId() uint32 { + if m != nil && m.TargetAccountId != nil { + return *m.TargetAccountId + } + return 0 +} + +func (m *CMsgDOTAGuildSetAccountRoleRequest) GetTargetRole() uint32 { + if m != nil && m.TargetRole != nil { + return *m.TargetRole + } + return 0 +} + +type CMsgDOTAGuildSetAccountRoleResponse struct { + Result *CMsgDOTAGuildSetAccountRoleResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAGuildSetAccountRoleResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildSetAccountRoleResponse) Reset() { *m = CMsgDOTAGuildSetAccountRoleResponse{} } +func (m *CMsgDOTAGuildSetAccountRoleResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildSetAccountRoleResponse) ProtoMessage() {} +func (*CMsgDOTAGuildSetAccountRoleResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{125} +} + +const Default_CMsgDOTAGuildSetAccountRoleResponse_Result CMsgDOTAGuildSetAccountRoleResponse_EResult = CMsgDOTAGuildSetAccountRoleResponse_SUCCESS + +func (m *CMsgDOTAGuildSetAccountRoleResponse) GetResult() CMsgDOTAGuildSetAccountRoleResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAGuildSetAccountRoleResponse_Result +} + +type CMsgDOTAGuildInviteAccountRequest struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + TargetAccountId *uint32 `protobuf:"varint,2,opt,name=target_account_id" json:"target_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildInviteAccountRequest) Reset() { *m = CMsgDOTAGuildInviteAccountRequest{} } +func (m *CMsgDOTAGuildInviteAccountRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildInviteAccountRequest) ProtoMessage() {} +func (*CMsgDOTAGuildInviteAccountRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{126} +} + +func (m *CMsgDOTAGuildInviteAccountRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildInviteAccountRequest) GetTargetAccountId() uint32 { + if m != nil && m.TargetAccountId != nil { + return *m.TargetAccountId + } + return 0 +} + +type CMsgDOTAGuildInviteAccountResponse struct { + Result *CMsgDOTAGuildInviteAccountResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAGuildInviteAccountResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildInviteAccountResponse) Reset() { *m = CMsgDOTAGuildInviteAccountResponse{} } +func (m *CMsgDOTAGuildInviteAccountResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildInviteAccountResponse) ProtoMessage() {} +func (*CMsgDOTAGuildInviteAccountResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{127} +} + +const Default_CMsgDOTAGuildInviteAccountResponse_Result CMsgDOTAGuildInviteAccountResponse_EResult = CMsgDOTAGuildInviteAccountResponse_SUCCESS + +func (m *CMsgDOTAGuildInviteAccountResponse) GetResult() CMsgDOTAGuildInviteAccountResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAGuildInviteAccountResponse_Result +} + +type CMsgDOTAGuildCancelInviteRequest struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + TargetAccountId *uint32 `protobuf:"varint,2,opt,name=target_account_id" json:"target_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildCancelInviteRequest) Reset() { *m = CMsgDOTAGuildCancelInviteRequest{} } +func (m *CMsgDOTAGuildCancelInviteRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildCancelInviteRequest) ProtoMessage() {} +func (*CMsgDOTAGuildCancelInviteRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{128} +} + +func (m *CMsgDOTAGuildCancelInviteRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildCancelInviteRequest) GetTargetAccountId() uint32 { + if m != nil && m.TargetAccountId != nil { + return *m.TargetAccountId + } + return 0 +} + +type CMsgDOTAGuildCancelInviteResponse struct { + Result *CMsgDOTAGuildCancelInviteResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAGuildCancelInviteResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildCancelInviteResponse) Reset() { *m = CMsgDOTAGuildCancelInviteResponse{} } +func (m *CMsgDOTAGuildCancelInviteResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildCancelInviteResponse) ProtoMessage() {} +func (*CMsgDOTAGuildCancelInviteResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{129} +} + +const Default_CMsgDOTAGuildCancelInviteResponse_Result CMsgDOTAGuildCancelInviteResponse_EResult = CMsgDOTAGuildCancelInviteResponse_SUCCESS + +func (m *CMsgDOTAGuildCancelInviteResponse) GetResult() CMsgDOTAGuildCancelInviteResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAGuildCancelInviteResponse_Result +} + +type CMsgDOTAGuildUpdateDetailsRequest struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Logo *uint64 `protobuf:"varint,2,opt,name=logo" json:"logo,omitempty"` + BaseLogo *uint64 `protobuf:"varint,3,opt,name=base_logo" json:"base_logo,omitempty"` + BannerLogo *uint64 `protobuf:"varint,4,opt,name=banner_logo" json:"banner_logo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildUpdateDetailsRequest) Reset() { *m = CMsgDOTAGuildUpdateDetailsRequest{} } +func (m *CMsgDOTAGuildUpdateDetailsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildUpdateDetailsRequest) ProtoMessage() {} +func (*CMsgDOTAGuildUpdateDetailsRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{130} +} + +func (m *CMsgDOTAGuildUpdateDetailsRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildUpdateDetailsRequest) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAGuildUpdateDetailsRequest) GetBaseLogo() uint64 { + if m != nil && m.BaseLogo != nil { + return *m.BaseLogo + } + return 0 +} + +func (m *CMsgDOTAGuildUpdateDetailsRequest) GetBannerLogo() uint64 { + if m != nil && m.BannerLogo != nil { + return *m.BannerLogo + } + return 0 +} + +type CMsgDOTAGuildUpdateDetailsResponse struct { + Result *CMsgDOTAGuildUpdateDetailsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAGuildUpdateDetailsResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildUpdateDetailsResponse) Reset() { *m = CMsgDOTAGuildUpdateDetailsResponse{} } +func (m *CMsgDOTAGuildUpdateDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildUpdateDetailsResponse) ProtoMessage() {} +func (*CMsgDOTAGuildUpdateDetailsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{131} +} + +const Default_CMsgDOTAGuildUpdateDetailsResponse_Result CMsgDOTAGuildUpdateDetailsResponse_EResult = CMsgDOTAGuildUpdateDetailsResponse_SUCCESS + +func (m *CMsgDOTAGuildUpdateDetailsResponse) GetResult() CMsgDOTAGuildUpdateDetailsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAGuildUpdateDetailsResponse_Result +} + +type CMsgDOTAGCToGCUpdateOpenGuildPartyRequest struct { + PartyId *uint64 `protobuf:"varint,1,opt,name=party_id" json:"party_id,omitempty"` + GuildId *uint32 `protobuf:"varint,2,opt,name=guild_id" json:"guild_id,omitempty"` + MemberAccountIds []uint32 `protobuf:"varint,3,rep,name=member_account_ids" json:"member_account_ids,omitempty"` + Description *string `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) Reset() { + *m = CMsgDOTAGCToGCUpdateOpenGuildPartyRequest{} +} +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) ProtoMessage() {} +func (*CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{132} +} + +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) GetMemberAccountIds() []uint32 { + if m != nil { + return m.MemberAccountIds + } + return nil +} + +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyRequest) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +type CMsgDOTAGCToGCUpdateOpenGuildPartyResponse struct { + MaintainAssociation *bool `protobuf:"varint,1,opt,name=maintain_association" json:"maintain_association,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyResponse) Reset() { + *m = CMsgDOTAGCToGCUpdateOpenGuildPartyResponse{} +} +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAGCToGCUpdateOpenGuildPartyResponse) ProtoMessage() {} +func (*CMsgDOTAGCToGCUpdateOpenGuildPartyResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{133} +} + +func (m *CMsgDOTAGCToGCUpdateOpenGuildPartyResponse) GetMaintainAssociation() bool { + if m != nil && m.MaintainAssociation != nil { + return *m.MaintainAssociation + } + return false +} + +type CMsgDOTAGCToGCDestroyOpenGuildPartyRequest struct { + PartyId *uint64 `protobuf:"varint,1,opt,name=party_id" json:"party_id,omitempty"` + GuildId *uint32 `protobuf:"varint,2,opt,name=guild_id" json:"guild_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGCToGCDestroyOpenGuildPartyRequest) Reset() { + *m = CMsgDOTAGCToGCDestroyOpenGuildPartyRequest{} +} +func (m *CMsgDOTAGCToGCDestroyOpenGuildPartyRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAGCToGCDestroyOpenGuildPartyRequest) ProtoMessage() {} +func (*CMsgDOTAGCToGCDestroyOpenGuildPartyRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{134} +} + +func (m *CMsgDOTAGCToGCDestroyOpenGuildPartyRequest) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CMsgDOTAGCToGCDestroyOpenGuildPartyRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +type CMsgDOTAGCToGCDestroyOpenGuildPartyResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGCToGCDestroyOpenGuildPartyResponse) Reset() { + *m = CMsgDOTAGCToGCDestroyOpenGuildPartyResponse{} +} +func (m *CMsgDOTAGCToGCDestroyOpenGuildPartyResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAGCToGCDestroyOpenGuildPartyResponse) ProtoMessage() {} +func (*CMsgDOTAGCToGCDestroyOpenGuildPartyResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{135} +} + +type CMsgDOTAPartySetOpenGuildRequest struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Description *string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPartySetOpenGuildRequest) Reset() { *m = CMsgDOTAPartySetOpenGuildRequest{} } +func (m *CMsgDOTAPartySetOpenGuildRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPartySetOpenGuildRequest) ProtoMessage() {} +func (*CMsgDOTAPartySetOpenGuildRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{136} +} + +func (m *CMsgDOTAPartySetOpenGuildRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAPartySetOpenGuildRequest) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +type CMsgDOTAPartySetOpenGuildResponse struct { + Result *CMsgDOTAPartySetOpenGuildResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAPartySetOpenGuildResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPartySetOpenGuildResponse) Reset() { *m = CMsgDOTAPartySetOpenGuildResponse{} } +func (m *CMsgDOTAPartySetOpenGuildResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPartySetOpenGuildResponse) ProtoMessage() {} +func (*CMsgDOTAPartySetOpenGuildResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{137} +} + +const Default_CMsgDOTAPartySetOpenGuildResponse_Result CMsgDOTAPartySetOpenGuildResponse_EResult = CMsgDOTAPartySetOpenGuildResponse_SUCCESS + +func (m *CMsgDOTAPartySetOpenGuildResponse) GetResult() CMsgDOTAPartySetOpenGuildResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAPartySetOpenGuildResponse_Result +} + +type CMsgDOTAJoinOpenGuildPartyRequest struct { + PartyId *uint64 `protobuf:"varint,1,opt,name=party_id" json:"party_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAJoinOpenGuildPartyRequest) Reset() { *m = CMsgDOTAJoinOpenGuildPartyRequest{} } +func (m *CMsgDOTAJoinOpenGuildPartyRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAJoinOpenGuildPartyRequest) ProtoMessage() {} +func (*CMsgDOTAJoinOpenGuildPartyRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{138} +} + +func (m *CMsgDOTAJoinOpenGuildPartyRequest) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +type CMsgDOTAJoinOpenGuildPartyResponse struct { + Result *CMsgDOTAJoinOpenGuildPartyResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAJoinOpenGuildPartyResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAJoinOpenGuildPartyResponse) Reset() { *m = CMsgDOTAJoinOpenGuildPartyResponse{} } +func (m *CMsgDOTAJoinOpenGuildPartyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAJoinOpenGuildPartyResponse) ProtoMessage() {} +func (*CMsgDOTAJoinOpenGuildPartyResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{139} +} + +const Default_CMsgDOTAJoinOpenGuildPartyResponse_Result CMsgDOTAJoinOpenGuildPartyResponse_EResult = CMsgDOTAJoinOpenGuildPartyResponse_SUCCESS + +func (m *CMsgDOTAJoinOpenGuildPartyResponse) GetResult() CMsgDOTAJoinOpenGuildPartyResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAJoinOpenGuildPartyResponse_Result +} + +type CMsgDOTAGuildOpenPartyRefresh struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + OpenParties []*CMsgDOTAGuildOpenPartyRefresh_OpenParty `protobuf:"bytes,2,rep,name=open_parties" json:"open_parties,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildOpenPartyRefresh) Reset() { *m = CMsgDOTAGuildOpenPartyRefresh{} } +func (m *CMsgDOTAGuildOpenPartyRefresh) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildOpenPartyRefresh) ProtoMessage() {} +func (*CMsgDOTAGuildOpenPartyRefresh) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{140} } + +func (m *CMsgDOTAGuildOpenPartyRefresh) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildOpenPartyRefresh) GetOpenParties() []*CMsgDOTAGuildOpenPartyRefresh_OpenParty { + if m != nil { + return m.OpenParties + } + return nil +} + +type CMsgDOTAGuildOpenPartyRefresh_OpenParty struct { + PartyId *uint64 `protobuf:"varint,1,opt,name=party_id" json:"party_id,omitempty"` + MemberAccountIds []uint32 `protobuf:"varint,2,rep,name=member_account_ids" json:"member_account_ids,omitempty"` + TimeCreated *uint32 `protobuf:"varint,3,opt,name=time_created" json:"time_created,omitempty"` + Description *string `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildOpenPartyRefresh_OpenParty) Reset() { + *m = CMsgDOTAGuildOpenPartyRefresh_OpenParty{} +} +func (m *CMsgDOTAGuildOpenPartyRefresh_OpenParty) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildOpenPartyRefresh_OpenParty) ProtoMessage() {} +func (*CMsgDOTAGuildOpenPartyRefresh_OpenParty) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{140, 0} +} + +func (m *CMsgDOTAGuildOpenPartyRefresh_OpenParty) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CMsgDOTAGuildOpenPartyRefresh_OpenParty) GetMemberAccountIds() []uint32 { + if m != nil { + return m.MemberAccountIds + } + return nil +} + +func (m *CMsgDOTAGuildOpenPartyRefresh_OpenParty) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *CMsgDOTAGuildOpenPartyRefresh_OpenParty) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +type CMsgDOTARequestGuildData struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestGuildData) Reset() { *m = CMsgDOTARequestGuildData{} } +func (m *CMsgDOTARequestGuildData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestGuildData) ProtoMessage() {} +func (*CMsgDOTARequestGuildData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{141} } + +type CMsgDOTAGuildInviteData struct { + InvitedToGuild *bool `protobuf:"varint,1,opt,name=invited_to_guild" json:"invited_to_guild,omitempty"` + GuildId *uint32 `protobuf:"varint,2,opt,name=guild_id" json:"guild_id,omitempty"` + GuildName *string `protobuf:"bytes,3,opt,name=guild_name" json:"guild_name,omitempty"` + GuildTag *string `protobuf:"bytes,4,opt,name=guild_tag" json:"guild_tag,omitempty"` + Logo *uint64 `protobuf:"varint,5,opt,name=logo" json:"logo,omitempty"` + Inviter *uint32 `protobuf:"varint,6,opt,name=inviter" json:"inviter,omitempty"` + InviterName *string `protobuf:"bytes,7,opt,name=inviter_name" json:"inviter_name,omitempty"` + MemberCount *uint32 `protobuf:"varint,8,opt,name=member_count" json:"member_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildInviteData) Reset() { *m = CMsgDOTAGuildInviteData{} } +func (m *CMsgDOTAGuildInviteData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildInviteData) ProtoMessage() {} +func (*CMsgDOTAGuildInviteData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{142} } + +func (m *CMsgDOTAGuildInviteData) GetInvitedToGuild() bool { + if m != nil && m.InvitedToGuild != nil { + return *m.InvitedToGuild + } + return false +} + +func (m *CMsgDOTAGuildInviteData) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildInviteData) GetGuildName() string { + if m != nil && m.GuildName != nil { + return *m.GuildName + } + return "" +} + +func (m *CMsgDOTAGuildInviteData) GetGuildTag() string { + if m != nil && m.GuildTag != nil { + return *m.GuildTag + } + return "" +} + +func (m *CMsgDOTAGuildInviteData) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAGuildInviteData) GetInviter() uint32 { + if m != nil && m.Inviter != nil { + return *m.Inviter + } + return 0 +} + +func (m *CMsgDOTAGuildInviteData) GetInviterName() string { + if m != nil && m.InviterName != nil { + return *m.InviterName + } + return "" +} + +func (m *CMsgDOTAGuildInviteData) GetMemberCount() uint32 { + if m != nil && m.MemberCount != nil { + return *m.MemberCount + } + return 0 +} + +type CMsgDOTAGuildUpdateMessage struct { + Message *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"` + GuildId *uint32 `protobuf:"varint,2,opt,name=guild_id" json:"guild_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildUpdateMessage) Reset() { *m = CMsgDOTAGuildUpdateMessage{} } +func (m *CMsgDOTAGuildUpdateMessage) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildUpdateMessage) ProtoMessage() {} +func (*CMsgDOTAGuildUpdateMessage) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{143} } + +func (m *CMsgDOTAGuildUpdateMessage) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgDOTAGuildUpdateMessage) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +type CMsgDOTAGuildEditLogoRequest struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Logo *uint64 `protobuf:"varint,2,opt,name=logo" json:"logo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildEditLogoRequest) Reset() { *m = CMsgDOTAGuildEditLogoRequest{} } +func (m *CMsgDOTAGuildEditLogoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildEditLogoRequest) ProtoMessage() {} +func (*CMsgDOTAGuildEditLogoRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{144} } + +func (m *CMsgDOTAGuildEditLogoRequest) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildEditLogoRequest) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +type CMsgDOTAGuildEditLogoResponse struct { + GuildId *uint32 `protobuf:"varint,1,opt,name=guild_id" json:"guild_id,omitempty"` + Result *CMsgDOTAGuildEditLogoResponse_EResult `protobuf:"varint,2,opt,name=result,enum=CMsgDOTAGuildEditLogoResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGuildEditLogoResponse) Reset() { *m = CMsgDOTAGuildEditLogoResponse{} } +func (m *CMsgDOTAGuildEditLogoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGuildEditLogoResponse) ProtoMessage() {} +func (*CMsgDOTAGuildEditLogoResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{145} } + +const Default_CMsgDOTAGuildEditLogoResponse_Result CMsgDOTAGuildEditLogoResponse_EResult = CMsgDOTAGuildEditLogoResponse_SUCCESS + +func (m *CMsgDOTAGuildEditLogoResponse) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CMsgDOTAGuildEditLogoResponse) GetResult() CMsgDOTAGuildEditLogoResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAGuildEditLogoResponse_Result +} + +type CMsgDOTAReportsRemainingRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAReportsRemainingRequest) Reset() { *m = CMsgDOTAReportsRemainingRequest{} } +func (m *CMsgDOTAReportsRemainingRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAReportsRemainingRequest) ProtoMessage() {} +func (*CMsgDOTAReportsRemainingRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{146} +} + +type CMsgDOTAReportsRemainingResponse struct { + NumPositiveReportsRemaining *uint32 `protobuf:"varint,1,opt,name=num_positive_reports_remaining" json:"num_positive_reports_remaining,omitempty"` + NumNegativeReportsRemaining *uint32 `protobuf:"varint,2,opt,name=num_negative_reports_remaining" json:"num_negative_reports_remaining,omitempty"` + NumPositiveReportsTotal *uint32 `protobuf:"varint,3,opt,name=num_positive_reports_total" json:"num_positive_reports_total,omitempty"` + NumNegativeReportsTotal *uint32 `protobuf:"varint,4,opt,name=num_negative_reports_total" json:"num_negative_reports_total,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAReportsRemainingResponse) Reset() { *m = CMsgDOTAReportsRemainingResponse{} } +func (m *CMsgDOTAReportsRemainingResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAReportsRemainingResponse) ProtoMessage() {} +func (*CMsgDOTAReportsRemainingResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{147} +} + +func (m *CMsgDOTAReportsRemainingResponse) GetNumPositiveReportsRemaining() uint32 { + if m != nil && m.NumPositiveReportsRemaining != nil { + return *m.NumPositiveReportsRemaining + } + return 0 +} + +func (m *CMsgDOTAReportsRemainingResponse) GetNumNegativeReportsRemaining() uint32 { + if m != nil && m.NumNegativeReportsRemaining != nil { + return *m.NumNegativeReportsRemaining + } + return 0 +} + +func (m *CMsgDOTAReportsRemainingResponse) GetNumPositiveReportsTotal() uint32 { + if m != nil && m.NumPositiveReportsTotal != nil { + return *m.NumPositiveReportsTotal + } + return 0 +} + +func (m *CMsgDOTAReportsRemainingResponse) GetNumNegativeReportsTotal() uint32 { + if m != nil && m.NumNegativeReportsTotal != nil { + return *m.NumNegativeReportsTotal + } + return 0 +} + +type CMsgDOTASubmitPlayerReport struct { + TargetAccountId *uint32 `protobuf:"varint,1,opt,name=target_account_id" json:"target_account_id,omitempty"` + ReportFlags *uint32 `protobuf:"varint,2,opt,name=report_flags" json:"report_flags,omitempty"` + Comment *string `protobuf:"bytes,5,opt,name=comment" json:"comment,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASubmitPlayerReport) Reset() { *m = CMsgDOTASubmitPlayerReport{} } +func (m *CMsgDOTASubmitPlayerReport) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASubmitPlayerReport) ProtoMessage() {} +func (*CMsgDOTASubmitPlayerReport) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{148} } + +func (m *CMsgDOTASubmitPlayerReport) GetTargetAccountId() uint32 { + if m != nil && m.TargetAccountId != nil { + return *m.TargetAccountId + } + return 0 +} + +func (m *CMsgDOTASubmitPlayerReport) GetReportFlags() uint32 { + if m != nil && m.ReportFlags != nil { + return *m.ReportFlags + } + return 0 +} + +func (m *CMsgDOTASubmitPlayerReport) GetComment() string { + if m != nil && m.Comment != nil { + return *m.Comment + } + return "" +} + +type CMsgDOTASubmitPlayerReportResponse struct { + TargetAccountId *uint32 `protobuf:"varint,1,opt,name=target_account_id" json:"target_account_id,omitempty"` + ReportFlags *uint32 `protobuf:"varint,2,opt,name=report_flags" json:"report_flags,omitempty"` + Result *uint32 `protobuf:"varint,3,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASubmitPlayerReportResponse) Reset() { *m = CMsgDOTASubmitPlayerReportResponse{} } +func (m *CMsgDOTASubmitPlayerReportResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASubmitPlayerReportResponse) ProtoMessage() {} +func (*CMsgDOTASubmitPlayerReportResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{149} +} + +func (m *CMsgDOTASubmitPlayerReportResponse) GetTargetAccountId() uint32 { + if m != nil && m.TargetAccountId != nil { + return *m.TargetAccountId + } + return 0 +} + +func (m *CMsgDOTASubmitPlayerReportResponse) GetReportFlags() uint32 { + if m != nil && m.ReportFlags != nil { + return *m.ReportFlags + } + return 0 +} + +func (m *CMsgDOTASubmitPlayerReportResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgDOTAReportCountsRequest struct { + TargetAccountId *uint32 `protobuf:"varint,1,opt,name=target_account_id" json:"target_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAReportCountsRequest) Reset() { *m = CMsgDOTAReportCountsRequest{} } +func (m *CMsgDOTAReportCountsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAReportCountsRequest) ProtoMessage() {} +func (*CMsgDOTAReportCountsRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{150} } + +func (m *CMsgDOTAReportCountsRequest) GetTargetAccountId() uint32 { + if m != nil && m.TargetAccountId != nil { + return *m.TargetAccountId + } + return 0 +} + +type CMsgDOTAReportCountsResponse struct { + TargetAccountId *uint32 `protobuf:"varint,1,opt,name=target_account_id" json:"target_account_id,omitempty"` + LeadershipCount *uint32 `protobuf:"varint,2,opt,name=leadership_count" json:"leadership_count,omitempty"` + TeachingCount *uint32 `protobuf:"varint,3,opt,name=teaching_count" json:"teaching_count,omitempty"` + FriendlyCount *uint32 `protobuf:"varint,4,opt,name=friendly_count" json:"friendly_count,omitempty"` + ForgivingCount *uint32 `protobuf:"varint,5,opt,name=forgiving_count" json:"forgiving_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAReportCountsResponse) Reset() { *m = CMsgDOTAReportCountsResponse{} } +func (m *CMsgDOTAReportCountsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAReportCountsResponse) ProtoMessage() {} +func (*CMsgDOTAReportCountsResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{151} } + +func (m *CMsgDOTAReportCountsResponse) GetTargetAccountId() uint32 { + if m != nil && m.TargetAccountId != nil { + return *m.TargetAccountId + } + return 0 +} + +func (m *CMsgDOTAReportCountsResponse) GetLeadershipCount() uint32 { + if m != nil && m.LeadershipCount != nil { + return *m.LeadershipCount + } + return 0 +} + +func (m *CMsgDOTAReportCountsResponse) GetTeachingCount() uint32 { + if m != nil && m.TeachingCount != nil { + return *m.TeachingCount + } + return 0 +} + +func (m *CMsgDOTAReportCountsResponse) GetFriendlyCount() uint32 { + if m != nil && m.FriendlyCount != nil { + return *m.FriendlyCount + } + return 0 +} + +func (m *CMsgDOTAReportCountsResponse) GetForgivingCount() uint32 { + if m != nil && m.ForgivingCount != nil { + return *m.ForgivingCount + } + return 0 +} + +type CMsgDOTAKickedFromMatchmakingQueue struct { + MatchType *MatchType `protobuf:"varint,1,opt,name=match_type,enum=MatchType,def=0" json:"match_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAKickedFromMatchmakingQueue) Reset() { *m = CMsgDOTAKickedFromMatchmakingQueue{} } +func (m *CMsgDOTAKickedFromMatchmakingQueue) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAKickedFromMatchmakingQueue) ProtoMessage() {} +func (*CMsgDOTAKickedFromMatchmakingQueue) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{152} +} + +const Default_CMsgDOTAKickedFromMatchmakingQueue_MatchType MatchType = MatchType_MATCH_TYPE_CASUAL + +func (m *CMsgDOTAKickedFromMatchmakingQueue) GetMatchType() MatchType { + if m != nil && m.MatchType != nil { + return *m.MatchType + } + return Default_CMsgDOTAKickedFromMatchmakingQueue_MatchType +} + +type CMsgDOTARequestSaveGames struct { + ServerRegion *uint32 `protobuf:"varint,1,opt,name=server_region" json:"server_region,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestSaveGames) Reset() { *m = CMsgDOTARequestSaveGames{} } +func (m *CMsgDOTARequestSaveGames) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestSaveGames) ProtoMessage() {} +func (*CMsgDOTARequestSaveGames) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{153} } + +func (m *CMsgDOTARequestSaveGames) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return 0 +} + +type CMsgDOTARequestSaveGamesResponse struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + SaveGames []*CDOTASaveGame `protobuf:"bytes,2,rep,name=save_games" json:"save_games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARequestSaveGamesResponse) Reset() { *m = CMsgDOTARequestSaveGamesResponse{} } +func (m *CMsgDOTARequestSaveGamesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARequestSaveGamesResponse) ProtoMessage() {} +func (*CMsgDOTARequestSaveGamesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{154} +} + +func (m *CMsgDOTARequestSaveGamesResponse) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTARequestSaveGamesResponse) GetSaveGames() []*CDOTASaveGame { + if m != nil { + return m.SaveGames + } + return nil +} + +type CMsgWatchGame struct { + ServerSteamid *uint64 `protobuf:"fixed64,1,opt,name=server_steamid" json:"server_steamid,omitempty"` + ClientVersion *uint32 `protobuf:"varint,2,opt,name=client_version" json:"client_version,omitempty"` + WatchServerSteamid *uint64 `protobuf:"fixed64,3,opt,name=watch_server_steamid" json:"watch_server_steamid,omitempty"` + LobbyId *uint64 `protobuf:"varint,4,opt,name=lobby_id" json:"lobby_id,omitempty"` + Regions []uint32 `protobuf:"varint,5,rep,name=regions" json:"regions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgWatchGame) Reset() { *m = CMsgWatchGame{} } +func (m *CMsgWatchGame) String() string { return proto.CompactTextString(m) } +func (*CMsgWatchGame) ProtoMessage() {} +func (*CMsgWatchGame) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{155} } + +func (m *CMsgWatchGame) GetServerSteamid() uint64 { + if m != nil && m.ServerSteamid != nil { + return *m.ServerSteamid + } + return 0 +} + +func (m *CMsgWatchGame) GetClientVersion() uint32 { + if m != nil && m.ClientVersion != nil { + return *m.ClientVersion + } + return 0 +} + +func (m *CMsgWatchGame) GetWatchServerSteamid() uint64 { + if m != nil && m.WatchServerSteamid != nil { + return *m.WatchServerSteamid + } + return 0 +} + +func (m *CMsgWatchGame) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgWatchGame) GetRegions() []uint32 { + if m != nil { + return m.Regions + } + return nil +} + +type CMsgCancelWatchGame struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCancelWatchGame) Reset() { *m = CMsgCancelWatchGame{} } +func (m *CMsgCancelWatchGame) String() string { return proto.CompactTextString(m) } +func (*CMsgCancelWatchGame) ProtoMessage() {} +func (*CMsgCancelWatchGame) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{156} } + +type CMsgWatchGameResponse struct { + WatchGameResult *CMsgWatchGameResponse_WatchGameResult `protobuf:"varint,1,opt,name=watch_game_result,enum=CMsgWatchGameResponse_WatchGameResult,def=0" json:"watch_game_result,omitempty"` + SourceTvPublicAddr *uint32 `protobuf:"varint,2,opt,name=source_tv_public_addr" json:"source_tv_public_addr,omitempty"` + SourceTvPrivateAddr *uint32 `protobuf:"varint,3,opt,name=source_tv_private_addr" json:"source_tv_private_addr,omitempty"` + SourceTvPort *uint32 `protobuf:"varint,4,opt,name=source_tv_port" json:"source_tv_port,omitempty"` + GameServerSteamid *uint64 `protobuf:"fixed64,5,opt,name=game_server_steamid" json:"game_server_steamid,omitempty"` + WatchServerSteamid *uint64 `protobuf:"fixed64,6,opt,name=watch_server_steamid" json:"watch_server_steamid,omitempty"` + WatchTvUniqueSecretCode *uint64 `protobuf:"fixed64,7,opt,name=watch_tv_unique_secret_code" json:"watch_tv_unique_secret_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgWatchGameResponse) Reset() { *m = CMsgWatchGameResponse{} } +func (m *CMsgWatchGameResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgWatchGameResponse) ProtoMessage() {} +func (*CMsgWatchGameResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{157} } + +const Default_CMsgWatchGameResponse_WatchGameResult CMsgWatchGameResponse_WatchGameResult = CMsgWatchGameResponse_PENDING + +func (m *CMsgWatchGameResponse) GetWatchGameResult() CMsgWatchGameResponse_WatchGameResult { + if m != nil && m.WatchGameResult != nil { + return *m.WatchGameResult + } + return Default_CMsgWatchGameResponse_WatchGameResult +} + +func (m *CMsgWatchGameResponse) GetSourceTvPublicAddr() uint32 { + if m != nil && m.SourceTvPublicAddr != nil { + return *m.SourceTvPublicAddr + } + return 0 +} + +func (m *CMsgWatchGameResponse) GetSourceTvPrivateAddr() uint32 { + if m != nil && m.SourceTvPrivateAddr != nil { + return *m.SourceTvPrivateAddr + } + return 0 +} + +func (m *CMsgWatchGameResponse) GetSourceTvPort() uint32 { + if m != nil && m.SourceTvPort != nil { + return *m.SourceTvPort + } + return 0 +} + +func (m *CMsgWatchGameResponse) GetGameServerSteamid() uint64 { + if m != nil && m.GameServerSteamid != nil { + return *m.GameServerSteamid + } + return 0 +} + +func (m *CMsgWatchGameResponse) GetWatchServerSteamid() uint64 { + if m != nil && m.WatchServerSteamid != nil { + return *m.WatchServerSteamid + } + return 0 +} + +func (m *CMsgWatchGameResponse) GetWatchTvUniqueSecretCode() uint64 { + if m != nil && m.WatchTvUniqueSecretCode != nil { + return *m.WatchTvUniqueSecretCode + } + return 0 +} + +type CMsgPartyLeaderWatchGamePrompt struct { + GameServerSteamid *uint64 `protobuf:"fixed64,5,opt,name=game_server_steamid" json:"game_server_steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPartyLeaderWatchGamePrompt) Reset() { *m = CMsgPartyLeaderWatchGamePrompt{} } +func (m *CMsgPartyLeaderWatchGamePrompt) String() string { return proto.CompactTextString(m) } +func (*CMsgPartyLeaderWatchGamePrompt) ProtoMessage() {} +func (*CMsgPartyLeaderWatchGamePrompt) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{158} +} + +func (m *CMsgPartyLeaderWatchGamePrompt) GetGameServerSteamid() uint64 { + if m != nil && m.GameServerSteamid != nil { + return *m.GameServerSteamid + } + return 0 +} + +type CMsgGCMatchDetailsRequest struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCMatchDetailsRequest) Reset() { *m = CMsgGCMatchDetailsRequest{} } +func (m *CMsgGCMatchDetailsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCMatchDetailsRequest) ProtoMessage() {} +func (*CMsgGCMatchDetailsRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{159} } + +func (m *CMsgGCMatchDetailsRequest) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +type CMsgGCMatchDetailsResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + Match *CMsgDOTAMatch `protobuf:"bytes,2,opt,name=match" json:"match,omitempty"` + Vote *DOTAMatchVote `protobuf:"varint,3,opt,name=vote,enum=DOTAMatchVote,def=0" json:"vote,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCMatchDetailsResponse) Reset() { *m = CMsgGCMatchDetailsResponse{} } +func (m *CMsgGCMatchDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCMatchDetailsResponse) ProtoMessage() {} +func (*CMsgGCMatchDetailsResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{160} } + +const Default_CMsgGCMatchDetailsResponse_Vote DOTAMatchVote = DOTAMatchVote_DOTAMatchVote_INVALID + +func (m *CMsgGCMatchDetailsResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgGCMatchDetailsResponse) GetMatch() *CMsgDOTAMatch { + if m != nil { + return m.Match + } + return nil +} + +func (m *CMsgGCMatchDetailsResponse) GetVote() DOTAMatchVote { + if m != nil && m.Vote != nil { + return *m.Vote + } + return Default_CMsgGCMatchDetailsResponse_Vote +} + +type CMsgServerToGCMatchDetailsRequest struct { + MatchIds []uint64 `protobuf:"varint,1,rep,name=match_ids" json:"match_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgServerToGCMatchDetailsRequest) Reset() { *m = CMsgServerToGCMatchDetailsRequest{} } +func (m *CMsgServerToGCMatchDetailsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgServerToGCMatchDetailsRequest) ProtoMessage() {} +func (*CMsgServerToGCMatchDetailsRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{161} +} + +func (m *CMsgServerToGCMatchDetailsRequest) GetMatchIds() []uint64 { + if m != nil { + return m.MatchIds + } + return nil +} + +type CMsgGCToServerMatchDetailsResponse struct { + Matches []*CMsgDOTAMatch `protobuf:"bytes,1,rep,name=matches" json:"matches,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToServerMatchDetailsResponse) Reset() { *m = CMsgGCToServerMatchDetailsResponse{} } +func (m *CMsgGCToServerMatchDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToServerMatchDetailsResponse) ProtoMessage() {} +func (*CMsgGCToServerMatchDetailsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{162} +} + +func (m *CMsgGCToServerMatchDetailsResponse) GetMatches() []*CMsgDOTAMatch { + if m != nil { + return m.Matches + } + return nil +} + +type CMsgDOTAProfileRequest struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + RequestName *bool `protobuf:"varint,2,opt,name=request_name" json:"request_name,omitempty"` + Engine *ESourceEngine `protobuf:"varint,3,opt,name=engine,enum=ESourceEngine,def=0" json:"engine,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileRequest) Reset() { *m = CMsgDOTAProfileRequest{} } +func (m *CMsgDOTAProfileRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileRequest) ProtoMessage() {} +func (*CMsgDOTAProfileRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{163} } + +const Default_CMsgDOTAProfileRequest_Engine ESourceEngine = ESourceEngine_k_ESE_Source1 + +func (m *CMsgDOTAProfileRequest) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAProfileRequest) GetRequestName() bool { + if m != nil && m.RequestName != nil { + return *m.RequestName + } + return false +} + +func (m *CMsgDOTAProfileRequest) GetEngine() ESourceEngine { + if m != nil && m.Engine != nil { + return *m.Engine + } + return Default_CMsgDOTAProfileRequest_Engine +} + +type CMsgDOTAProfileResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + GameAccountClient *CSODOTAGameAccountClient `protobuf:"bytes,2,opt,name=game_account_client" json:"game_account_client,omitempty"` + LatestMatches []*CMsgDOTAMatch `protobuf:"bytes,3,rep,name=latest_matches" json:"latest_matches,omitempty"` + Heroes []*CMsgDOTAProfileResponse_PlayedHero `protobuf:"bytes,4,rep,name=heroes" json:"heroes,omitempty"` + PlayerName *string `protobuf:"bytes,5,opt,name=player_name" json:"player_name,omitempty"` + TeamName *string `protobuf:"bytes,6,opt,name=team_name" json:"team_name,omitempty"` + TeamTag *string `protobuf:"bytes,7,opt,name=team_tag" json:"team_tag,omitempty"` + TeamLogo *uint64 `protobuf:"varint,8,opt,name=team_logo" json:"team_logo,omitempty"` + ShowcaseHero *CMsgDOTAProfileResponse_ShowcaseHero `protobuf:"bytes,9,opt,name=showcase_hero" json:"showcase_hero,omitempty"` + LeaguePasses []*CMsgDOTAProfileResponse_LeaguePass `protobuf:"bytes,10,rep,name=league_passes" json:"league_passes,omitempty"` + EventTickets []*CMsgDOTAProfileResponse_EventTicket `protobuf:"bytes,11,rep,name=event_tickets" json:"event_tickets,omitempty"` + TeamId *uint32 `protobuf:"varint,12,opt,name=team_id" json:"team_id,omitempty"` + HasPassport *bool `protobuf:"varint,13,opt,name=has_passport" json:"has_passport,omitempty"` + FeaturedItems []*CMsgDOTAProfileResponse_FeaturedItem `protobuf:"bytes,14,rep,name=featured_items" json:"featured_items,omitempty"` + AbandonPercent *uint32 `protobuf:"varint,15,opt,name=abandon_percent" json:"abandon_percent,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileResponse) Reset() { *m = CMsgDOTAProfileResponse{} } +func (m *CMsgDOTAProfileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileResponse) ProtoMessage() {} +func (*CMsgDOTAProfileResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{164} } + +func (m *CMsgDOTAProfileResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgDOTAProfileResponse) GetGameAccountClient() *CSODOTAGameAccountClient { + if m != nil { + return m.GameAccountClient + } + return nil +} + +func (m *CMsgDOTAProfileResponse) GetLatestMatches() []*CMsgDOTAMatch { + if m != nil { + return m.LatestMatches + } + return nil +} + +func (m *CMsgDOTAProfileResponse) GetHeroes() []*CMsgDOTAProfileResponse_PlayedHero { + if m != nil { + return m.Heroes + } + return nil +} + +func (m *CMsgDOTAProfileResponse) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +func (m *CMsgDOTAProfileResponse) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTAProfileResponse) GetTeamTag() string { + if m != nil && m.TeamTag != nil { + return *m.TeamTag + } + return "" +} + +func (m *CMsgDOTAProfileResponse) GetTeamLogo() uint64 { + if m != nil && m.TeamLogo != nil { + return *m.TeamLogo + } + return 0 +} + +func (m *CMsgDOTAProfileResponse) GetShowcaseHero() *CMsgDOTAProfileResponse_ShowcaseHero { + if m != nil { + return m.ShowcaseHero + } + return nil +} + +func (m *CMsgDOTAProfileResponse) GetLeaguePasses() []*CMsgDOTAProfileResponse_LeaguePass { + if m != nil { + return m.LeaguePasses + } + return nil +} + +func (m *CMsgDOTAProfileResponse) GetEventTickets() []*CMsgDOTAProfileResponse_EventTicket { + if m != nil { + return m.EventTickets + } + return nil +} + +func (m *CMsgDOTAProfileResponse) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTAProfileResponse) GetHasPassport() bool { + if m != nil && m.HasPassport != nil { + return *m.HasPassport + } + return false +} + +func (m *CMsgDOTAProfileResponse) GetFeaturedItems() []*CMsgDOTAProfileResponse_FeaturedItem { + if m != nil { + return m.FeaturedItems + } + return nil +} + +func (m *CMsgDOTAProfileResponse) GetAbandonPercent() uint32 { + if m != nil && m.AbandonPercent != nil { + return *m.AbandonPercent + } + return 0 +} + +type CMsgDOTAProfileResponse_PlayedHero struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + Wins *uint32 `protobuf:"varint,2,opt,name=wins" json:"wins,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileResponse_PlayedHero) Reset() { *m = CMsgDOTAProfileResponse_PlayedHero{} } +func (m *CMsgDOTAProfileResponse_PlayedHero) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileResponse_PlayedHero) ProtoMessage() {} +func (*CMsgDOTAProfileResponse_PlayedHero) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{164, 0} +} + +func (m *CMsgDOTAProfileResponse_PlayedHero) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAProfileResponse_PlayedHero) GetWins() uint32 { + if m != nil && m.Wins != nil { + return *m.Wins + } + return 0 +} + +type CMsgDOTAProfileResponse_ShowcaseHero struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + ObjectData [][]byte `protobuf:"bytes,2,rep,name=object_data" json:"object_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileResponse_ShowcaseHero) Reset() { *m = CMsgDOTAProfileResponse_ShowcaseHero{} } +func (m *CMsgDOTAProfileResponse_ShowcaseHero) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileResponse_ShowcaseHero) ProtoMessage() {} +func (*CMsgDOTAProfileResponse_ShowcaseHero) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{164, 1} +} + +func (m *CMsgDOTAProfileResponse_ShowcaseHero) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAProfileResponse_ShowcaseHero) GetObjectData() [][]byte { + if m != nil { + return m.ObjectData + } + return nil +} + +type CMsgDOTAProfileResponse_LeaguePass struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + ItemDef *uint32 `protobuf:"varint,2,opt,name=item_def" json:"item_def,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileResponse_LeaguePass) Reset() { *m = CMsgDOTAProfileResponse_LeaguePass{} } +func (m *CMsgDOTAProfileResponse_LeaguePass) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileResponse_LeaguePass) ProtoMessage() {} +func (*CMsgDOTAProfileResponse_LeaguePass) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{164, 2} +} + +func (m *CMsgDOTAProfileResponse_LeaguePass) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTAProfileResponse_LeaguePass) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +type CMsgDOTAProfileResponse_EventTicket struct { + EventId *uint32 `protobuf:"varint,1,opt,name=event_id" json:"event_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileResponse_EventTicket) Reset() { *m = CMsgDOTAProfileResponse_EventTicket{} } +func (m *CMsgDOTAProfileResponse_EventTicket) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileResponse_EventTicket) ProtoMessage() {} +func (*CMsgDOTAProfileResponse_EventTicket) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{164, 3} +} + +func (m *CMsgDOTAProfileResponse_EventTicket) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +type CMsgDOTAProfileResponse_FeaturedItem struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + ObjectData []byte `protobuf:"bytes,2,opt,name=object_data" json:"object_data,omitempty"` + SlotIndex *uint32 `protobuf:"varint,3,opt,name=slot_index" json:"slot_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileResponse_FeaturedItem) Reset() { *m = CMsgDOTAProfileResponse_FeaturedItem{} } +func (m *CMsgDOTAProfileResponse_FeaturedItem) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileResponse_FeaturedItem) ProtoMessage() {} +func (*CMsgDOTAProfileResponse_FeaturedItem) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{164, 4} +} + +func (m *CMsgDOTAProfileResponse_FeaturedItem) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgDOTAProfileResponse_FeaturedItem) GetObjectData() []byte { + if m != nil { + return m.ObjectData + } + return nil +} + +func (m *CMsgDOTAProfileResponse_FeaturedItem) GetSlotIndex() uint32 { + if m != nil && m.SlotIndex != nil { + return *m.SlotIndex + } + return 0 +} + +type CMsgDOTAProfileTickets struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + AccountId *uint32 `protobuf:"varint,2,opt,name=account_id" json:"account_id,omitempty"` + LeaguePasses []*CMsgDOTAProfileTickets_LeaguePass `protobuf:"bytes,3,rep,name=league_passes" json:"league_passes,omitempty"` + EventTickets []*CMsgDOTAProfileTickets_EventTicket `protobuf:"bytes,4,rep,name=event_tickets" json:"event_tickets,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileTickets) Reset() { *m = CMsgDOTAProfileTickets{} } +func (m *CMsgDOTAProfileTickets) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileTickets) ProtoMessage() {} +func (*CMsgDOTAProfileTickets) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{165} } + +func (m *CMsgDOTAProfileTickets) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgDOTAProfileTickets) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAProfileTickets) GetLeaguePasses() []*CMsgDOTAProfileTickets_LeaguePass { + if m != nil { + return m.LeaguePasses + } + return nil +} + +func (m *CMsgDOTAProfileTickets) GetEventTickets() []*CMsgDOTAProfileTickets_EventTicket { + if m != nil { + return m.EventTickets + } + return nil +} + +type CMsgDOTAProfileTickets_LeaguePass struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + ItemDef *uint32 `protobuf:"varint,2,opt,name=item_def" json:"item_def,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileTickets_LeaguePass) Reset() { *m = CMsgDOTAProfileTickets_LeaguePass{} } +func (m *CMsgDOTAProfileTickets_LeaguePass) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileTickets_LeaguePass) ProtoMessage() {} +func (*CMsgDOTAProfileTickets_LeaguePass) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{165, 0} +} + +func (m *CMsgDOTAProfileTickets_LeaguePass) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTAProfileTickets_LeaguePass) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +type CMsgDOTAProfileTickets_EventTicket struct { + EventId *uint32 `protobuf:"varint,1,opt,name=event_id" json:"event_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileTickets_EventTicket) Reset() { *m = CMsgDOTAProfileTickets_EventTicket{} } +func (m *CMsgDOTAProfileTickets_EventTicket) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileTickets_EventTicket) ProtoMessage() {} +func (*CMsgDOTAProfileTickets_EventTicket) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{165, 1} +} + +func (m *CMsgDOTAProfileTickets_EventTicket) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +type CMsgClientToGCGetProfileTickets struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetProfileTickets) Reset() { *m = CMsgClientToGCGetProfileTickets{} } +func (m *CMsgClientToGCGetProfileTickets) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetProfileTickets) ProtoMessage() {} +func (*CMsgClientToGCGetProfileTickets) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{166} +} + +func (m *CMsgClientToGCGetProfileTickets) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgGCSteamProfileRequest struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCSteamProfileRequest) Reset() { *m = CMsgGCSteamProfileRequest{} } +func (m *CMsgGCSteamProfileRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCSteamProfileRequest) ProtoMessage() {} +func (*CMsgGCSteamProfileRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{167} } + +func (m *CMsgGCSteamProfileRequest) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgGCSteamProfileRequestResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCSteamProfileRequestResponse) Reset() { *m = CMsgGCSteamProfileRequestResponse{} } +func (m *CMsgGCSteamProfileRequestResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCSteamProfileRequestResponse) ProtoMessage() {} +func (*CMsgGCSteamProfileRequestResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{168} +} + +func (m *CMsgGCSteamProfileRequestResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgDOTAClearNotifySuccessfulReport struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAClearNotifySuccessfulReport) Reset() { *m = CMsgDOTAClearNotifySuccessfulReport{} } +func (m *CMsgDOTAClearNotifySuccessfulReport) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAClearNotifySuccessfulReport) ProtoMessage() {} +func (*CMsgDOTAClearNotifySuccessfulReport) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{169} +} + +type CMsgDOTAWelcome struct { + TournamentAdmin *bool `protobuf:"varint,3,opt,name=tournament_admin" json:"tournament_admin,omitempty"` + TournamentBroadcaster *bool `protobuf:"varint,4,opt,name=tournament_broadcaster" json:"tournament_broadcaster,omitempty"` + StoreItemHash *uint32 `protobuf:"varint,5,opt,name=store_item_hash" json:"store_item_hash,omitempty"` + Timeplayedconsecutively *uint32 `protobuf:"varint,6,opt,name=timeplayedconsecutively" json:"timeplayedconsecutively,omitempty"` + Allow_3RdPartyMatchHistory *bool `protobuf:"varint,7,opt,name=allow_3rd_party_match_history" json:"allow_3rd_party_match_history,omitempty"` + PartnerAccountType *PartnerAccountType `protobuf:"varint,8,opt,name=partner_account_type,enum=PartnerAccountType,def=0" json:"partner_account_type,omitempty"` + BannedWordListWordId *uint32 `protobuf:"varint,9,opt,name=banned_word_list_word_id" json:"banned_word_list_word_id,omitempty"` + PartnerAccountState *uint32 `protobuf:"varint,11,opt,name=partner_account_state" json:"partner_account_state,omitempty"` + LastTimePlayed *uint32 `protobuf:"varint,12,opt,name=last_time_played" json:"last_time_played,omitempty"` + LastIpAddress *uint32 `protobuf:"varint,13,opt,name=last_ip_address" json:"last_ip_address,omitempty"` + Shutdownlawterminateminutes *uint32 `protobuf:"varint,15,opt,name=shutdownlawterminateminutes" json:"shutdownlawterminateminutes,omitempty"` + BannedWordListVersion *uint32 `protobuf:"varint,16,opt,name=banned_word_list_version" json:"banned_word_list_version,omitempty"` + ProfilePrivate *bool `protobuf:"varint,17,opt,name=profile_private" json:"profile_private,omitempty"` + Currency *uint32 `protobuf:"varint,18,opt,name=currency" json:"currency,omitempty"` + BangNo *uint32 `protobuf:"varint,19,opt,name=bang_no" json:"bang_no,omitempty"` + ShouldRequestPlayerOrigin *bool `protobuf:"varint,20,opt,name=should_request_player_origin" json:"should_request_player_origin,omitempty"` + CompendiumUnlocks *uint64 `protobuf:"varint,21,opt,name=compendium_unlocks" json:"compendium_unlocks,omitempty"` + GcSocacheFileVersion *uint32 `protobuf:"varint,22,opt,name=gc_socache_file_version" json:"gc_socache_file_version,omitempty"` + LocalizationDigests []*CMsgDOTAWelcome_LocalizationDigest `protobuf:"bytes,23,rep,name=localization_digests" json:"localization_digests,omitempty"` + IsPerfectWorldTestAccount *bool `protobuf:"varint,24,opt,name=is_perfect_world_test_account" json:"is_perfect_world_test_account,omitempty"` + ActiveEvents []EEvent `protobuf:"varint,25,rep,name=active_events,enum=EEvent" json:"active_events,omitempty"` + ExtraMessages []*CMsgDOTAWelcome_CExtraMsg `protobuf:"bytes,26,rep,name=extra_messages" json:"extra_messages,omitempty"` + MinimumRecentItemId *uint64 `protobuf:"varint,27,opt,name=minimum_recent_item_id" json:"minimum_recent_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAWelcome) Reset() { *m = CMsgDOTAWelcome{} } +func (m *CMsgDOTAWelcome) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAWelcome) ProtoMessage() {} +func (*CMsgDOTAWelcome) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{170} } + +const Default_CMsgDOTAWelcome_PartnerAccountType PartnerAccountType = PartnerAccountType_PARTNER_NONE + +func (m *CMsgDOTAWelcome) GetTournamentAdmin() bool { + if m != nil && m.TournamentAdmin != nil { + return *m.TournamentAdmin + } + return false +} + +func (m *CMsgDOTAWelcome) GetTournamentBroadcaster() bool { + if m != nil && m.TournamentBroadcaster != nil { + return *m.TournamentBroadcaster + } + return false +} + +func (m *CMsgDOTAWelcome) GetStoreItemHash() uint32 { + if m != nil && m.StoreItemHash != nil { + return *m.StoreItemHash + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetTimeplayedconsecutively() uint32 { + if m != nil && m.Timeplayedconsecutively != nil { + return *m.Timeplayedconsecutively + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetAllow_3RdPartyMatchHistory() bool { + if m != nil && m.Allow_3RdPartyMatchHistory != nil { + return *m.Allow_3RdPartyMatchHistory + } + return false +} + +func (m *CMsgDOTAWelcome) GetPartnerAccountType() PartnerAccountType { + if m != nil && m.PartnerAccountType != nil { + return *m.PartnerAccountType + } + return Default_CMsgDOTAWelcome_PartnerAccountType +} + +func (m *CMsgDOTAWelcome) GetBannedWordListWordId() uint32 { + if m != nil && m.BannedWordListWordId != nil { + return *m.BannedWordListWordId + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetPartnerAccountState() uint32 { + if m != nil && m.PartnerAccountState != nil { + return *m.PartnerAccountState + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetLastTimePlayed() uint32 { + if m != nil && m.LastTimePlayed != nil { + return *m.LastTimePlayed + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetLastIpAddress() uint32 { + if m != nil && m.LastIpAddress != nil { + return *m.LastIpAddress + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetShutdownlawterminateminutes() uint32 { + if m != nil && m.Shutdownlawterminateminutes != nil { + return *m.Shutdownlawterminateminutes + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetBannedWordListVersion() uint32 { + if m != nil && m.BannedWordListVersion != nil { + return *m.BannedWordListVersion + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetProfilePrivate() bool { + if m != nil && m.ProfilePrivate != nil { + return *m.ProfilePrivate + } + return false +} + +func (m *CMsgDOTAWelcome) GetCurrency() uint32 { + if m != nil && m.Currency != nil { + return *m.Currency + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetBangNo() uint32 { + if m != nil && m.BangNo != nil { + return *m.BangNo + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetShouldRequestPlayerOrigin() bool { + if m != nil && m.ShouldRequestPlayerOrigin != nil { + return *m.ShouldRequestPlayerOrigin + } + return false +} + +func (m *CMsgDOTAWelcome) GetCompendiumUnlocks() uint64 { + if m != nil && m.CompendiumUnlocks != nil { + return *m.CompendiumUnlocks + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetGcSocacheFileVersion() uint32 { + if m != nil && m.GcSocacheFileVersion != nil { + return *m.GcSocacheFileVersion + } + return 0 +} + +func (m *CMsgDOTAWelcome) GetLocalizationDigests() []*CMsgDOTAWelcome_LocalizationDigest { + if m != nil { + return m.LocalizationDigests + } + return nil +} + +func (m *CMsgDOTAWelcome) GetIsPerfectWorldTestAccount() bool { + if m != nil && m.IsPerfectWorldTestAccount != nil { + return *m.IsPerfectWorldTestAccount + } + return false +} + +func (m *CMsgDOTAWelcome) GetActiveEvents() []EEvent { + if m != nil { + return m.ActiveEvents + } + return nil +} + +func (m *CMsgDOTAWelcome) GetExtraMessages() []*CMsgDOTAWelcome_CExtraMsg { + if m != nil { + return m.ExtraMessages + } + return nil +} + +func (m *CMsgDOTAWelcome) GetMinimumRecentItemId() uint64 { + if m != nil && m.MinimumRecentItemId != nil { + return *m.MinimumRecentItemId + } + return 0 +} + +type CMsgDOTAWelcome_LocalizationDigest struct { + Context *string `protobuf:"bytes,1,opt,name=context" json:"context,omitempty"` + EnglishLanguageFileSha1 *CMsgSHA1Digest `protobuf:"bytes,2,opt,name=english_language_file_sha1" json:"english_language_file_sha1,omitempty"` + ClientLanguageFileSha1 *CMsgSHA1Digest `protobuf:"bytes,3,opt,name=client_language_file_sha1" json:"client_language_file_sha1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAWelcome_LocalizationDigest) Reset() { *m = CMsgDOTAWelcome_LocalizationDigest{} } +func (m *CMsgDOTAWelcome_LocalizationDigest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAWelcome_LocalizationDigest) ProtoMessage() {} +func (*CMsgDOTAWelcome_LocalizationDigest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{170, 0} +} + +func (m *CMsgDOTAWelcome_LocalizationDigest) GetContext() string { + if m != nil && m.Context != nil { + return *m.Context + } + return "" +} + +func (m *CMsgDOTAWelcome_LocalizationDigest) GetEnglishLanguageFileSha1() *CMsgSHA1Digest { + if m != nil { + return m.EnglishLanguageFileSha1 + } + return nil +} + +func (m *CMsgDOTAWelcome_LocalizationDigest) GetClientLanguageFileSha1() *CMsgSHA1Digest { + if m != nil { + return m.ClientLanguageFileSha1 + } + return nil +} + +type CMsgDOTAWelcome_CExtraMsg struct { + Id *uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"` + Contents []byte `protobuf:"bytes,2,opt,name=contents" json:"contents,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAWelcome_CExtraMsg) Reset() { *m = CMsgDOTAWelcome_CExtraMsg{} } +func (m *CMsgDOTAWelcome_CExtraMsg) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAWelcome_CExtraMsg) ProtoMessage() {} +func (*CMsgDOTAWelcome_CExtraMsg) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{170, 1} } + +func (m *CMsgDOTAWelcome_CExtraMsg) GetId() uint32 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CMsgDOTAWelcome_CExtraMsg) GetContents() []byte { + if m != nil { + return m.Contents + } + return nil +} + +type CSODOTAGameHeroFavorites struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + HeroId *uint32 `protobuf:"varint,2,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAGameHeroFavorites) Reset() { *m = CSODOTAGameHeroFavorites{} } +func (m *CSODOTAGameHeroFavorites) String() string { return proto.CompactTextString(m) } +func (*CSODOTAGameHeroFavorites) ProtoMessage() {} +func (*CSODOTAGameHeroFavorites) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{171} } + +func (m *CSODOTAGameHeroFavorites) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSODOTAGameHeroFavorites) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgDOTAHeroFavoritesAdd struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHeroFavoritesAdd) Reset() { *m = CMsgDOTAHeroFavoritesAdd{} } +func (m *CMsgDOTAHeroFavoritesAdd) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHeroFavoritesAdd) ProtoMessage() {} +func (*CMsgDOTAHeroFavoritesAdd) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{172} } + +func (m *CMsgDOTAHeroFavoritesAdd) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgDOTAHeroFavoritesRemove struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHeroFavoritesRemove) Reset() { *m = CMsgDOTAHeroFavoritesRemove{} } +func (m *CMsgDOTAHeroFavoritesRemove) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHeroFavoritesRemove) ProtoMessage() {} +func (*CMsgDOTAHeroFavoritesRemove) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{173} } + +func (m *CMsgDOTAHeroFavoritesRemove) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgSetShowcaseHero struct { + ShowcaseHeroId *uint32 `protobuf:"varint,1,opt,name=showcase_hero_id" json:"showcase_hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSetShowcaseHero) Reset() { *m = CMsgSetShowcaseHero{} } +func (m *CMsgSetShowcaseHero) String() string { return proto.CompactTextString(m) } +func (*CMsgSetShowcaseHero) ProtoMessage() {} +func (*CMsgSetShowcaseHero) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{174} } + +func (m *CMsgSetShowcaseHero) GetShowcaseHeroId() uint32 { + if m != nil && m.ShowcaseHeroId != nil { + return *m.ShowcaseHeroId + } + return 0 +} + +type CMsgSetFeaturedItems struct { + FeaturedItemId []uint64 `protobuf:"varint,1,rep,name=featured_item_id" json:"featured_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSetFeaturedItems) Reset() { *m = CMsgSetFeaturedItems{} } +func (m *CMsgSetFeaturedItems) String() string { return proto.CompactTextString(m) } +func (*CMsgSetFeaturedItems) ProtoMessage() {} +func (*CMsgSetFeaturedItems) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{175} } + +func (m *CMsgSetFeaturedItems) GetFeaturedItemId() []uint64 { + if m != nil { + return m.FeaturedItemId + } + return nil +} + +type CMsgDOTAFeaturedItems struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + FeaturedItemId []uint64 `protobuf:"varint,2,rep,name=featured_item_id" json:"featured_item_id,omitempty"` + ObjectData [][]byte `protobuf:"bytes,3,rep,name=object_data" json:"object_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFeaturedItems) Reset() { *m = CMsgDOTAFeaturedItems{} } +func (m *CMsgDOTAFeaturedItems) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFeaturedItems) ProtoMessage() {} +func (*CMsgDOTAFeaturedItems) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{176} } + +func (m *CMsgDOTAFeaturedItems) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAFeaturedItems) GetFeaturedItemId() []uint64 { + if m != nil { + return m.FeaturedItemId + } + return nil +} + +func (m *CMsgDOTAFeaturedItems) GetObjectData() [][]byte { + if m != nil { + return m.ObjectData + } + return nil +} + +type CMsgRequestLeagueInfo struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestLeagueInfo) Reset() { *m = CMsgRequestLeagueInfo{} } +func (m *CMsgRequestLeagueInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestLeagueInfo) ProtoMessage() {} +func (*CMsgRequestLeagueInfo) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{177} } + +type CDynamicLeagueData struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + LastMatchTime *uint32 `protobuf:"fixed32,2,opt,name=last_match_time" json:"last_match_time,omitempty"` + PrizePoolUsd *uint32 `protobuf:"varint,3,opt,name=prize_pool_usd" json:"prize_pool_usd,omitempty"` + HasLiveMatches *bool `protobuf:"varint,4,opt,name=has_live_matches" json:"has_live_matches,omitempty"` + IsCompendiumPublic *bool `protobuf:"varint,5,opt,name=is_compendium_public" json:"is_compendium_public,omitempty"` + CompendiumVersion *uint32 `protobuf:"varint,6,opt,name=compendium_version" json:"compendium_version,omitempty"` + CompendiumContentVersion *uint32 `protobuf:"varint,7,opt,name=compendium_content_version" json:"compendium_content_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDynamicLeagueData) Reset() { *m = CDynamicLeagueData{} } +func (m *CDynamicLeagueData) String() string { return proto.CompactTextString(m) } +func (*CDynamicLeagueData) ProtoMessage() {} +func (*CDynamicLeagueData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{178} } + +func (m *CDynamicLeagueData) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CDynamicLeagueData) GetLastMatchTime() uint32 { + if m != nil && m.LastMatchTime != nil { + return *m.LastMatchTime + } + return 0 +} + +func (m *CDynamicLeagueData) GetPrizePoolUsd() uint32 { + if m != nil && m.PrizePoolUsd != nil { + return *m.PrizePoolUsd + } + return 0 +} + +func (m *CDynamicLeagueData) GetHasLiveMatches() bool { + if m != nil && m.HasLiveMatches != nil { + return *m.HasLiveMatches + } + return false +} + +func (m *CDynamicLeagueData) GetIsCompendiumPublic() bool { + if m != nil && m.IsCompendiumPublic != nil { + return *m.IsCompendiumPublic + } + return false +} + +func (m *CDynamicLeagueData) GetCompendiumVersion() uint32 { + if m != nil && m.CompendiumVersion != nil { + return *m.CompendiumVersion + } + return 0 +} + +func (m *CDynamicLeagueData) GetCompendiumContentVersion() uint32 { + if m != nil && m.CompendiumContentVersion != nil { + return *m.CompendiumContentVersion + } + return 0 +} + +type CStaticLeagueData struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Description *string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"` + BannerName *string `protobuf:"bytes,4,opt,name=banner_name" json:"banner_name,omitempty"` + ItemdefName *string `protobuf:"bytes,5,opt,name=itemdef_name" json:"itemdef_name,omitempty"` + Url *string `protobuf:"bytes,6,opt,name=url" json:"url,omitempty"` + ItemDefIndex *uint32 `protobuf:"varint,7,opt,name=item_def_index" json:"item_def_index,omitempty"` + HudSkinItemDefIndex *uint32 `protobuf:"varint,8,opt,name=hud_skin_item_def_index" json:"hud_skin_item_def_index,omitempty"` + LoadingScreenName *string `protobuf:"bytes,9,opt,name=loading_screen_name" json:"loading_screen_name,omitempty"` + BasePrizePool *uint32 `protobuf:"varint,10,opt,name=base_prize_pool" json:"base_prize_pool,omitempty"` + IsMajor *bool `protobuf:"varint,11,opt,name=is_major" json:"is_major,omitempty"` + SortOrder *uint32 `protobuf:"varint,12,opt,name=sort_order" json:"sort_order,omitempty"` + Tier *uint32 `protobuf:"varint,13,opt,name=tier" json:"tier,omitempty"` + AmateurRegion *uint32 `protobuf:"varint,14,opt,name=amateur_region" json:"amateur_region,omitempty"` + Organizer *string `protobuf:"bytes,15,opt,name=organizer" json:"organizer,omitempty"` + StartDate *uint32 `protobuf:"varint,16,opt,name=start_date" json:"start_date,omitempty"` + EndDate *uint32 `protobuf:"varint,17,opt,name=end_date" json:"end_date,omitempty"` + Location *string `protobuf:"bytes,18,opt,name=location" json:"location,omitempty"` + InventoryImage *string `protobuf:"bytes,19,opt,name=inventory_image" json:"inventory_image,omitempty"` + SquareImage *string `protobuf:"bytes,20,opt,name=square_image" json:"square_image,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CStaticLeagueData) Reset() { *m = CStaticLeagueData{} } +func (m *CStaticLeagueData) String() string { return proto.CompactTextString(m) } +func (*CStaticLeagueData) ProtoMessage() {} +func (*CStaticLeagueData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{179} } + +func (m *CStaticLeagueData) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CStaticLeagueData) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CStaticLeagueData) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CStaticLeagueData) GetBannerName() string { + if m != nil && m.BannerName != nil { + return *m.BannerName + } + return "" +} + +func (m *CStaticLeagueData) GetItemdefName() string { + if m != nil && m.ItemdefName != nil { + return *m.ItemdefName + } + return "" +} + +func (m *CStaticLeagueData) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CStaticLeagueData) GetItemDefIndex() uint32 { + if m != nil && m.ItemDefIndex != nil { + return *m.ItemDefIndex + } + return 0 +} + +func (m *CStaticLeagueData) GetHudSkinItemDefIndex() uint32 { + if m != nil && m.HudSkinItemDefIndex != nil { + return *m.HudSkinItemDefIndex + } + return 0 +} + +func (m *CStaticLeagueData) GetLoadingScreenName() string { + if m != nil && m.LoadingScreenName != nil { + return *m.LoadingScreenName + } + return "" +} + +func (m *CStaticLeagueData) GetBasePrizePool() uint32 { + if m != nil && m.BasePrizePool != nil { + return *m.BasePrizePool + } + return 0 +} + +func (m *CStaticLeagueData) GetIsMajor() bool { + if m != nil && m.IsMajor != nil { + return *m.IsMajor + } + return false +} + +func (m *CStaticLeagueData) GetSortOrder() uint32 { + if m != nil && m.SortOrder != nil { + return *m.SortOrder + } + return 0 +} + +func (m *CStaticLeagueData) GetTier() uint32 { + if m != nil && m.Tier != nil { + return *m.Tier + } + return 0 +} + +func (m *CStaticLeagueData) GetAmateurRegion() uint32 { + if m != nil && m.AmateurRegion != nil { + return *m.AmateurRegion + } + return 0 +} + +func (m *CStaticLeagueData) GetOrganizer() string { + if m != nil && m.Organizer != nil { + return *m.Organizer + } + return "" +} + +func (m *CStaticLeagueData) GetStartDate() uint32 { + if m != nil && m.StartDate != nil { + return *m.StartDate + } + return 0 +} + +func (m *CStaticLeagueData) GetEndDate() uint32 { + if m != nil && m.EndDate != nil { + return *m.EndDate + } + return 0 +} + +func (m *CStaticLeagueData) GetLocation() string { + if m != nil && m.Location != nil { + return *m.Location + } + return "" +} + +func (m *CStaticLeagueData) GetInventoryImage() string { + if m != nil && m.InventoryImage != nil { + return *m.InventoryImage + } + return "" +} + +func (m *CStaticLeagueData) GetSquareImage() string { + if m != nil && m.SquareImage != nil { + return *m.SquareImage + } + return "" +} + +type CLeagueData struct { + DynamicData *CDynamicLeagueData `protobuf:"bytes,1,opt,name=dynamic_data" json:"dynamic_data,omitempty"` + StaticData *CStaticLeagueData `protobuf:"bytes,2,opt,name=static_data" json:"static_data,omitempty"` + IsOwned *bool `protobuf:"varint,3,opt,name=is_owned" json:"is_owned,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CLeagueData) Reset() { *m = CLeagueData{} } +func (m *CLeagueData) String() string { return proto.CompactTextString(m) } +func (*CLeagueData) ProtoMessage() {} +func (*CLeagueData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{180} } + +func (m *CLeagueData) GetDynamicData() *CDynamicLeagueData { + if m != nil { + return m.DynamicData + } + return nil +} + +func (m *CLeagueData) GetStaticData() *CStaticLeagueData { + if m != nil { + return m.StaticData + } + return nil +} + +func (m *CLeagueData) GetIsOwned() bool { + if m != nil && m.IsOwned != nil { + return *m.IsOwned + } + return false +} + +type CMsgResponseLeagueInfo struct { + Leagues []*CDynamicLeagueData `protobuf:"bytes,1,rep,name=leagues" json:"leagues,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgResponseLeagueInfo) Reset() { *m = CMsgResponseLeagueInfo{} } +func (m *CMsgResponseLeagueInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgResponseLeagueInfo) ProtoMessage() {} +func (*CMsgResponseLeagueInfo) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{181} } + +func (m *CMsgResponseLeagueInfo) GetLeagues() []*CDynamicLeagueData { + if m != nil { + return m.Leagues + } + return nil +} + +type CMsgDOTAMatchVotes struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + Votes []*CMsgDOTAMatchVotes_PlayerVote `protobuf:"bytes,2,rep,name=votes" json:"votes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchVotes) Reset() { *m = CMsgDOTAMatchVotes{} } +func (m *CMsgDOTAMatchVotes) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchVotes) ProtoMessage() {} +func (*CMsgDOTAMatchVotes) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{182} } + +func (m *CMsgDOTAMatchVotes) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgDOTAMatchVotes) GetVotes() []*CMsgDOTAMatchVotes_PlayerVote { + if m != nil { + return m.Votes + } + return nil +} + +type CMsgDOTAMatchVotes_PlayerVote struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Vote *uint32 `protobuf:"varint,2,opt,name=vote" json:"vote,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchVotes_PlayerVote) Reset() { *m = CMsgDOTAMatchVotes_PlayerVote{} } +func (m *CMsgDOTAMatchVotes_PlayerVote) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchVotes_PlayerVote) ProtoMessage() {} +func (*CMsgDOTAMatchVotes_PlayerVote) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{182, 0} +} + +func (m *CMsgDOTAMatchVotes_PlayerVote) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAMatchVotes_PlayerVote) GetVote() uint32 { + if m != nil && m.Vote != nil { + return *m.Vote + } + return 0 +} + +type CMsgCastMatchVote struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + Vote *DOTAMatchVote `protobuf:"varint,2,opt,name=vote,enum=DOTAMatchVote,def=0" json:"vote,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCastMatchVote) Reset() { *m = CMsgCastMatchVote{} } +func (m *CMsgCastMatchVote) String() string { return proto.CompactTextString(m) } +func (*CMsgCastMatchVote) ProtoMessage() {} +func (*CMsgCastMatchVote) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{183} } + +const Default_CMsgCastMatchVote_Vote DOTAMatchVote = DOTAMatchVote_DOTAMatchVote_INVALID + +func (m *CMsgCastMatchVote) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgCastMatchVote) GetVote() DOTAMatchVote { + if m != nil && m.Vote != nil { + return *m.Vote + } + return Default_CMsgCastMatchVote_Vote +} + +type CMsgRetrieveMatchVote struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + Incremental *uint32 `protobuf:"varint,2,opt,name=incremental" json:"incremental,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRetrieveMatchVote) Reset() { *m = CMsgRetrieveMatchVote{} } +func (m *CMsgRetrieveMatchVote) String() string { return proto.CompactTextString(m) } +func (*CMsgRetrieveMatchVote) ProtoMessage() {} +func (*CMsgRetrieveMatchVote) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{184} } + +func (m *CMsgRetrieveMatchVote) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgRetrieveMatchVote) GetIncremental() uint32 { + if m != nil && m.Incremental != nil { + return *m.Incremental + } + return 0 +} + +type CMsgMatchVoteResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Vote *DOTAMatchVote `protobuf:"varint,2,opt,name=vote,enum=DOTAMatchVote,def=0" json:"vote,omitempty"` + PositiveVotes *uint32 `protobuf:"varint,3,opt,name=positive_votes" json:"positive_votes,omitempty"` + NegativeVotes *uint32 `protobuf:"varint,4,opt,name=negative_votes" json:"negative_votes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgMatchVoteResponse) Reset() { *m = CMsgMatchVoteResponse{} } +func (m *CMsgMatchVoteResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgMatchVoteResponse) ProtoMessage() {} +func (*CMsgMatchVoteResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{185} } + +const Default_CMsgMatchVoteResponse_Eresult uint32 = 2 +const Default_CMsgMatchVoteResponse_Vote DOTAMatchVote = DOTAMatchVote_DOTAMatchVote_INVALID + +func (m *CMsgMatchVoteResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgMatchVoteResponse_Eresult +} + +func (m *CMsgMatchVoteResponse) GetVote() DOTAMatchVote { + if m != nil && m.Vote != nil { + return *m.Vote + } + return Default_CMsgMatchVoteResponse_Vote +} + +func (m *CMsgMatchVoteResponse) GetPositiveVotes() uint32 { + if m != nil && m.PositiveVotes != nil { + return *m.PositiveVotes + } + return 0 +} + +func (m *CMsgMatchVoteResponse) GetNegativeVotes() uint32 { + if m != nil && m.NegativeVotes != nil { + return *m.NegativeVotes + } + return 0 +} + +type CMsgDOTAHallOfFame struct { + Week *uint32 `protobuf:"varint,1,opt,name=week" json:"week,omitempty"` + FeaturedPlayers []*CMsgDOTAHallOfFame_FeaturedPlayer `protobuf:"bytes,2,rep,name=featured_players" json:"featured_players,omitempty"` + FeaturedFarmer *CMsgDOTAHallOfFame_FeaturedFarmer `protobuf:"bytes,3,opt,name=featured_farmer" json:"featured_farmer,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHallOfFame) Reset() { *m = CMsgDOTAHallOfFame{} } +func (m *CMsgDOTAHallOfFame) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHallOfFame) ProtoMessage() {} +func (*CMsgDOTAHallOfFame) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{186} } + +func (m *CMsgDOTAHallOfFame) GetWeek() uint32 { + if m != nil && m.Week != nil { + return *m.Week + } + return 0 +} + +func (m *CMsgDOTAHallOfFame) GetFeaturedPlayers() []*CMsgDOTAHallOfFame_FeaturedPlayer { + if m != nil { + return m.FeaturedPlayers + } + return nil +} + +func (m *CMsgDOTAHallOfFame) GetFeaturedFarmer() *CMsgDOTAHallOfFame_FeaturedFarmer { + if m != nil { + return m.FeaturedFarmer + } + return nil +} + +type CMsgDOTAHallOfFame_FeaturedPlayer struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + HeroId *uint32 `protobuf:"varint,2,opt,name=hero_id" json:"hero_id,omitempty"` + AverageScaledMetric *float32 `protobuf:"fixed32,3,opt,name=average_scaled_metric" json:"average_scaled_metric,omitempty"` + NumGames *uint32 `protobuf:"varint,4,opt,name=num_games" json:"num_games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHallOfFame_FeaturedPlayer) Reset() { *m = CMsgDOTAHallOfFame_FeaturedPlayer{} } +func (m *CMsgDOTAHallOfFame_FeaturedPlayer) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHallOfFame_FeaturedPlayer) ProtoMessage() {} +func (*CMsgDOTAHallOfFame_FeaturedPlayer) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{186, 0} +} + +func (m *CMsgDOTAHallOfFame_FeaturedPlayer) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAHallOfFame_FeaturedPlayer) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAHallOfFame_FeaturedPlayer) GetAverageScaledMetric() float32 { + if m != nil && m.AverageScaledMetric != nil { + return *m.AverageScaledMetric + } + return 0 +} + +func (m *CMsgDOTAHallOfFame_FeaturedPlayer) GetNumGames() uint32 { + if m != nil && m.NumGames != nil { + return *m.NumGames + } + return 0 +} + +type CMsgDOTAHallOfFame_FeaturedFarmer struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + HeroId *uint32 `protobuf:"varint,2,opt,name=hero_id" json:"hero_id,omitempty"` + GoldPerMin *uint32 `protobuf:"varint,3,opt,name=gold_per_min" json:"gold_per_min,omitempty"` + MatchId *uint64 `protobuf:"varint,4,opt,name=match_id" json:"match_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHallOfFame_FeaturedFarmer) Reset() { *m = CMsgDOTAHallOfFame_FeaturedFarmer{} } +func (m *CMsgDOTAHallOfFame_FeaturedFarmer) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHallOfFame_FeaturedFarmer) ProtoMessage() {} +func (*CMsgDOTAHallOfFame_FeaturedFarmer) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{186, 1} +} + +func (m *CMsgDOTAHallOfFame_FeaturedFarmer) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAHallOfFame_FeaturedFarmer) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAHallOfFame_FeaturedFarmer) GetGoldPerMin() uint32 { + if m != nil && m.GoldPerMin != nil { + return *m.GoldPerMin + } + return 0 +} + +func (m *CMsgDOTAHallOfFame_FeaturedFarmer) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +type CMsgDOTAHallOfFameRequest struct { + Week *uint32 `protobuf:"varint,1,opt,name=week" json:"week,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHallOfFameRequest) Reset() { *m = CMsgDOTAHallOfFameRequest{} } +func (m *CMsgDOTAHallOfFameRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHallOfFameRequest) ProtoMessage() {} +func (*CMsgDOTAHallOfFameRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{187} } + +func (m *CMsgDOTAHallOfFameRequest) GetWeek() uint32 { + if m != nil && m.Week != nil { + return *m.Week + } + return 0 +} + +type CMsgDOTAHallOfFameResponse struct { + HallOfFame *CMsgDOTAHallOfFame `protobuf:"bytes,1,opt,name=hall_of_fame" json:"hall_of_fame,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHallOfFameResponse) Reset() { *m = CMsgDOTAHallOfFameResponse{} } +func (m *CMsgDOTAHallOfFameResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHallOfFameResponse) ProtoMessage() {} +func (*CMsgDOTAHallOfFameResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{188} } + +const Default_CMsgDOTAHallOfFameResponse_Eresult uint32 = 2 + +func (m *CMsgDOTAHallOfFameResponse) GetHallOfFame() *CMsgDOTAHallOfFame { + if m != nil { + return m.HallOfFame + } + return nil +} + +func (m *CMsgDOTAHallOfFameResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDOTAHallOfFameResponse_Eresult +} + +type CMsgDOTAHalloweenHighScoreRequest struct { + Round *int32 `protobuf:"varint,1,opt,name=round,def=-1" json:"round,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHalloweenHighScoreRequest) Reset() { *m = CMsgDOTAHalloweenHighScoreRequest{} } +func (m *CMsgDOTAHalloweenHighScoreRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHalloweenHighScoreRequest) ProtoMessage() {} +func (*CMsgDOTAHalloweenHighScoreRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{189} +} + +const Default_CMsgDOTAHalloweenHighScoreRequest_Round int32 = -1 + +func (m *CMsgDOTAHalloweenHighScoreRequest) GetRound() int32 { + if m != nil && m.Round != nil { + return *m.Round + } + return Default_CMsgDOTAHalloweenHighScoreRequest_Round +} + +type CMsgDOTAHalloweenHighScoreResponse struct { + Score *uint32 `protobuf:"varint,1,opt,name=score" json:"score,omitempty"` + Match *CMsgDOTAMatch `protobuf:"bytes,2,opt,name=match" json:"match,omitempty"` + Eresult *uint32 `protobuf:"varint,3,opt,name=eresult" json:"eresult,omitempty"` + Round *int32 `protobuf:"varint,4,opt,name=round" json:"round,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHalloweenHighScoreResponse) Reset() { *m = CMsgDOTAHalloweenHighScoreResponse{} } +func (m *CMsgDOTAHalloweenHighScoreResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHalloweenHighScoreResponse) ProtoMessage() {} +func (*CMsgDOTAHalloweenHighScoreResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{190} +} + +func (m *CMsgDOTAHalloweenHighScoreResponse) GetScore() uint32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *CMsgDOTAHalloweenHighScoreResponse) GetMatch() *CMsgDOTAMatch { + if m != nil { + return m.Match + } + return nil +} + +func (m *CMsgDOTAHalloweenHighScoreResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgDOTAHalloweenHighScoreResponse) GetRound() int32 { + if m != nil && m.Round != nil { + return *m.Round + } + return 0 +} + +type CMsgDOTAStorePromoPagesRequest struct { + VersionSeen *uint32 `protobuf:"varint,1,opt,name=version_seen" json:"version_seen,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAStorePromoPagesRequest) Reset() { *m = CMsgDOTAStorePromoPagesRequest{} } +func (m *CMsgDOTAStorePromoPagesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAStorePromoPagesRequest) ProtoMessage() {} +func (*CMsgDOTAStorePromoPagesRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{191} +} + +func (m *CMsgDOTAStorePromoPagesRequest) GetVersionSeen() uint32 { + if m != nil && m.VersionSeen != nil { + return *m.VersionSeen + } + return 0 +} + +type CMsgDOTAStorePromoPagesResponse struct { + Pages []*CMsgDOTAStorePromoPagesResponse_PromoPage `protobuf:"bytes,1,rep,name=pages" json:"pages,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAStorePromoPagesResponse) Reset() { *m = CMsgDOTAStorePromoPagesResponse{} } +func (m *CMsgDOTAStorePromoPagesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAStorePromoPagesResponse) ProtoMessage() {} +func (*CMsgDOTAStorePromoPagesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{192} +} + +func (m *CMsgDOTAStorePromoPagesResponse) GetPages() []*CMsgDOTAStorePromoPagesResponse_PromoPage { + if m != nil { + return m.Pages + } + return nil +} + +type CMsgDOTAStorePromoPagesResponse_PromoPage struct { + PromoId *uint32 `protobuf:"varint,1,opt,name=promo_id" json:"promo_id,omitempty"` + Title *string `protobuf:"bytes,2,opt,name=title" json:"title,omitempty"` + Url *string `protobuf:"bytes,3,opt,name=url" json:"url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAStorePromoPagesResponse_PromoPage) Reset() { + *m = CMsgDOTAStorePromoPagesResponse_PromoPage{} +} +func (m *CMsgDOTAStorePromoPagesResponse_PromoPage) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAStorePromoPagesResponse_PromoPage) ProtoMessage() {} +func (*CMsgDOTAStorePromoPagesResponse_PromoPage) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{192, 0} +} + +func (m *CMsgDOTAStorePromoPagesResponse_PromoPage) GetPromoId() uint32 { + if m != nil && m.PromoId != nil { + return *m.PromoId + } + return 0 +} + +func (m *CMsgDOTAStorePromoPagesResponse_PromoPage) GetTitle() string { + if m != nil && m.Title != nil { + return *m.Title + } + return "" +} + +func (m *CMsgDOTAStorePromoPagesResponse_PromoPage) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +type CMsgLeagueScheduleBlockTeamInfo struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Logo *uint64 `protobuf:"varint,4,opt,name=logo" json:"logo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLeagueScheduleBlockTeamInfo) Reset() { *m = CMsgLeagueScheduleBlockTeamInfo{} } +func (m *CMsgLeagueScheduleBlockTeamInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgLeagueScheduleBlockTeamInfo) ProtoMessage() {} +func (*CMsgLeagueScheduleBlockTeamInfo) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{193} +} + +func (m *CMsgLeagueScheduleBlockTeamInfo) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgLeagueScheduleBlockTeamInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgLeagueScheduleBlockTeamInfo) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +type CMsgLeagueScheduleBlock struct { + BlockId *uint32 `protobuf:"varint,1,opt,name=block_id" json:"block_id,omitempty"` + StartTime *uint32 `protobuf:"varint,2,opt,name=start_time" json:"start_time,omitempty"` + Finals *bool `protobuf:"varint,4,opt,name=finals" json:"finals,omitempty"` + Comment *string `protobuf:"bytes,5,opt,name=comment" json:"comment,omitempty"` + Teams []*CMsgLeagueScheduleBlockTeamInfo `protobuf:"bytes,6,rep,name=teams" json:"teams,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLeagueScheduleBlock) Reset() { *m = CMsgLeagueScheduleBlock{} } +func (m *CMsgLeagueScheduleBlock) String() string { return proto.CompactTextString(m) } +func (*CMsgLeagueScheduleBlock) ProtoMessage() {} +func (*CMsgLeagueScheduleBlock) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{194} } + +func (m *CMsgLeagueScheduleBlock) GetBlockId() uint32 { + if m != nil && m.BlockId != nil { + return *m.BlockId + } + return 0 +} + +func (m *CMsgLeagueScheduleBlock) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgLeagueScheduleBlock) GetFinals() bool { + if m != nil && m.Finals != nil { + return *m.Finals + } + return false +} + +func (m *CMsgLeagueScheduleBlock) GetComment() string { + if m != nil && m.Comment != nil { + return *m.Comment + } + return "" +} + +func (m *CMsgLeagueScheduleBlock) GetTeams() []*CMsgLeagueScheduleBlockTeamInfo { + if m != nil { + return m.Teams + } + return nil +} + +type CMsgDOTALeague struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + Schedule []*CMsgLeagueScheduleBlock `protobuf:"bytes,2,rep,name=schedule" json:"schedule,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeague) Reset() { *m = CMsgDOTALeague{} } +func (m *CMsgDOTALeague) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeague) ProtoMessage() {} +func (*CMsgDOTALeague) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{195} } + +func (m *CMsgDOTALeague) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTALeague) GetSchedule() []*CMsgLeagueScheduleBlock { + if m != nil { + return m.Schedule + } + return nil +} + +type CMsgDOTALeagueScheduleRequest struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeagueScheduleRequest) Reset() { *m = CMsgDOTALeagueScheduleRequest{} } +func (m *CMsgDOTALeagueScheduleRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeagueScheduleRequest) ProtoMessage() {} +func (*CMsgDOTALeagueScheduleRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{196} } + +func (m *CMsgDOTALeagueScheduleRequest) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CMsgDOTALeagueScheduleResponse struct { + League *CMsgDOTALeague `protobuf:"bytes,1,opt,name=league" json:"league,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeagueScheduleResponse) Reset() { *m = CMsgDOTALeagueScheduleResponse{} } +func (m *CMsgDOTALeagueScheduleResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeagueScheduleResponse) ProtoMessage() {} +func (*CMsgDOTALeagueScheduleResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{197} +} + +const Default_CMsgDOTALeagueScheduleResponse_Eresult uint32 = 2 + +func (m *CMsgDOTALeagueScheduleResponse) GetLeague() *CMsgDOTALeague { + if m != nil { + return m.League + } + return nil +} + +func (m *CMsgDOTALeagueScheduleResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDOTALeagueScheduleResponse_Eresult +} + +type CMsgDOTALeagueScheduleEdit struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + Schedule *CMsgLeagueScheduleBlock `protobuf:"bytes,2,opt,name=schedule" json:"schedule,omitempty"` + DeleteBlock *bool `protobuf:"varint,3,opt,name=delete_block" json:"delete_block,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeagueScheduleEdit) Reset() { *m = CMsgDOTALeagueScheduleEdit{} } +func (m *CMsgDOTALeagueScheduleEdit) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeagueScheduleEdit) ProtoMessage() {} +func (*CMsgDOTALeagueScheduleEdit) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{198} } + +func (m *CMsgDOTALeagueScheduleEdit) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTALeagueScheduleEdit) GetSchedule() *CMsgLeagueScheduleBlock { + if m != nil { + return m.Schedule + } + return nil +} + +func (m *CMsgDOTALeagueScheduleEdit) GetDeleteBlock() bool { + if m != nil && m.DeleteBlock != nil { + return *m.DeleteBlock + } + return false +} + +type CMsgDOTALeagueScheduleEditResponse struct { + League *CMsgDOTALeague `protobuf:"bytes,1,opt,name=league" json:"league,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeagueScheduleEditResponse) Reset() { *m = CMsgDOTALeagueScheduleEditResponse{} } +func (m *CMsgDOTALeagueScheduleEditResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeagueScheduleEditResponse) ProtoMessage() {} +func (*CMsgDOTALeagueScheduleEditResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{199} +} + +const Default_CMsgDOTALeagueScheduleEditResponse_Eresult uint32 = 2 + +func (m *CMsgDOTALeagueScheduleEditResponse) GetLeague() *CMsgDOTALeague { + if m != nil { + return m.League + } + return nil +} + +func (m *CMsgDOTALeagueScheduleEditResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDOTALeagueScheduleEditResponse_Eresult +} + +type CMsgDOTALeaguesInMonthRequest struct { + Month *uint32 `protobuf:"varint,1,opt,name=month" json:"month,omitempty"` + Year *uint32 `protobuf:"varint,2,opt,name=year" json:"year,omitempty"` + Tier *uint32 `protobuf:"varint,3,opt,name=tier" json:"tier,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeaguesInMonthRequest) Reset() { *m = CMsgDOTALeaguesInMonthRequest{} } +func (m *CMsgDOTALeaguesInMonthRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeaguesInMonthRequest) ProtoMessage() {} +func (*CMsgDOTALeaguesInMonthRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{200} } + +func (m *CMsgDOTALeaguesInMonthRequest) GetMonth() uint32 { + if m != nil && m.Month != nil { + return *m.Month + } + return 0 +} + +func (m *CMsgDOTALeaguesInMonthRequest) GetYear() uint32 { + if m != nil && m.Year != nil { + return *m.Year + } + return 0 +} + +func (m *CMsgDOTALeaguesInMonthRequest) GetTier() uint32 { + if m != nil && m.Tier != nil { + return *m.Tier + } + return 0 +} + +type CMsgDOTALeaguesInMonthResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Month *uint32 `protobuf:"varint,2,opt,name=month" json:"month,omitempty"` + Year *uint32 `protobuf:"varint,3,opt,name=year" json:"year,omitempty"` + Leagues []*CMsgDOTALeague `protobuf:"bytes,4,rep,name=leagues" json:"leagues,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALeaguesInMonthResponse) Reset() { *m = CMsgDOTALeaguesInMonthResponse{} } +func (m *CMsgDOTALeaguesInMonthResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALeaguesInMonthResponse) ProtoMessage() {} +func (*CMsgDOTALeaguesInMonthResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{201} +} + +const Default_CMsgDOTALeaguesInMonthResponse_Eresult uint32 = 2 + +func (m *CMsgDOTALeaguesInMonthResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDOTALeaguesInMonthResponse_Eresult +} + +func (m *CMsgDOTALeaguesInMonthResponse) GetMonth() uint32 { + if m != nil && m.Month != nil { + return *m.Month + } + return 0 +} + +func (m *CMsgDOTALeaguesInMonthResponse) GetYear() uint32 { + if m != nil && m.Year != nil { + return *m.Year + } + return 0 +} + +func (m *CMsgDOTALeaguesInMonthResponse) GetLeagues() []*CMsgDOTALeague { + if m != nil { + return m.Leagues + } + return nil +} + +type CMsgMatchGroupServerStatus struct { + Ip []uint32 `protobuf:"fixed32,1,rep,packed,name=ip" json:"ip,omitempty"` + Port []uint32 `protobuf:"varint,2,rep,packed,name=port" json:"port,omitempty"` + AutoRegionSelectPingPenalty *int32 `protobuf:"zigzag32,3,opt,name=auto_region_select_ping_penalty" json:"auto_region_select_ping_penalty,omitempty"` + Status *EMatchGroupServerStatus `protobuf:"varint,4,opt,name=status,enum=EMatchGroupServerStatus,def=0" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgMatchGroupServerStatus) Reset() { *m = CMsgMatchGroupServerStatus{} } +func (m *CMsgMatchGroupServerStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgMatchGroupServerStatus) ProtoMessage() {} +func (*CMsgMatchGroupServerStatus) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{202} } + +const Default_CMsgMatchGroupServerStatus_Status EMatchGroupServerStatus = EMatchGroupServerStatus_k_EMatchGroupServerStatus_OK + +func (m *CMsgMatchGroupServerStatus) GetIp() []uint32 { + if m != nil { + return m.Ip + } + return nil +} + +func (m *CMsgMatchGroupServerStatus) GetPort() []uint32 { + if m != nil { + return m.Port + } + return nil +} + +func (m *CMsgMatchGroupServerStatus) GetAutoRegionSelectPingPenalty() int32 { + if m != nil && m.AutoRegionSelectPingPenalty != nil { + return *m.AutoRegionSelectPingPenalty + } + return 0 +} + +func (m *CMsgMatchGroupServerStatus) GetStatus() EMatchGroupServerStatus { + if m != nil && m.Status != nil { + return *m.Status + } + return Default_CMsgMatchGroupServerStatus_Status +} + +type CMsgMatchmakingGroupServerSample struct { + MatchGroups []*CMsgMatchGroupServerStatus `protobuf:"bytes,5,rep,name=match_groups" json:"match_groups,omitempty"` + LegacyServersToPing *uint32 `protobuf:"varint,2,opt,name=legacy_servers_to_ping" json:"legacy_servers_to_ping,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgMatchmakingGroupServerSample) Reset() { *m = CMsgMatchmakingGroupServerSample{} } +func (m *CMsgMatchmakingGroupServerSample) String() string { return proto.CompactTextString(m) } +func (*CMsgMatchmakingGroupServerSample) ProtoMessage() {} +func (*CMsgMatchmakingGroupServerSample) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{203} +} + +func (m *CMsgMatchmakingGroupServerSample) GetMatchGroups() []*CMsgMatchGroupServerStatus { + if m != nil { + return m.MatchGroups + } + return nil +} + +func (m *CMsgMatchmakingGroupServerSample) GetLegacyServersToPing() uint32 { + if m != nil && m.LegacyServersToPing != nil { + return *m.LegacyServersToPing + } + return 0 +} + +type CMsgDOTAMatchmakingStatsRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchmakingStatsRequest) Reset() { *m = CMsgDOTAMatchmakingStatsRequest{} } +func (m *CMsgDOTAMatchmakingStatsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchmakingStatsRequest) ProtoMessage() {} +func (*CMsgDOTAMatchmakingStatsRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{204} +} + +type CMsgDOTAMatchmakingStatsResponse struct { + MatchgroupsVersion *uint32 `protobuf:"varint,1,opt,name=matchgroups_version" json:"matchgroups_version,omitempty"` + SearchingPlayersByGroup []uint32 `protobuf:"varint,2,rep,name=searching_players_by_group" json:"searching_players_by_group,omitempty"` + SearchingPlayersByGroupSource2 []uint32 `protobuf:"varint,7,rep,name=searching_players_by_group_source2" json:"searching_players_by_group_source2,omitempty"` + GameserverSampleSource2 *CMsgMatchmakingGroupServerSample `protobuf:"bytes,6,opt,name=gameserver_sample_source2" json:"gameserver_sample_source2,omitempty"` + LegacyDisabledGroupsSource2 *uint32 `protobuf:"varint,8,opt,name=legacy_disabled_groups_source2" json:"legacy_disabled_groups_source2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAMatchmakingStatsResponse) Reset() { *m = CMsgDOTAMatchmakingStatsResponse{} } +func (m *CMsgDOTAMatchmakingStatsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAMatchmakingStatsResponse) ProtoMessage() {} +func (*CMsgDOTAMatchmakingStatsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{205} +} + +func (m *CMsgDOTAMatchmakingStatsResponse) GetMatchgroupsVersion() uint32 { + if m != nil && m.MatchgroupsVersion != nil { + return *m.MatchgroupsVersion + } + return 0 +} + +func (m *CMsgDOTAMatchmakingStatsResponse) GetSearchingPlayersByGroup() []uint32 { + if m != nil { + return m.SearchingPlayersByGroup + } + return nil +} + +func (m *CMsgDOTAMatchmakingStatsResponse) GetSearchingPlayersByGroupSource2() []uint32 { + if m != nil { + return m.SearchingPlayersByGroupSource2 + } + return nil +} + +func (m *CMsgDOTAMatchmakingStatsResponse) GetGameserverSampleSource2() *CMsgMatchmakingGroupServerSample { + if m != nil { + return m.GameserverSampleSource2 + } + return nil +} + +func (m *CMsgDOTAMatchmakingStatsResponse) GetLegacyDisabledGroupsSource2() uint32 { + if m != nil && m.LegacyDisabledGroupsSource2 != nil { + return *m.LegacyDisabledGroupsSource2 + } + return 0 +} + +type CMsgDOTASetMatchHistoryAccess struct { + Allow_3RdPartyMatchHistory *bool `protobuf:"varint,1,opt,name=allow_3rd_party_match_history" json:"allow_3rd_party_match_history,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASetMatchHistoryAccess) Reset() { *m = CMsgDOTASetMatchHistoryAccess{} } +func (m *CMsgDOTASetMatchHistoryAccess) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASetMatchHistoryAccess) ProtoMessage() {} +func (*CMsgDOTASetMatchHistoryAccess) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{206} } + +func (m *CMsgDOTASetMatchHistoryAccess) GetAllow_3RdPartyMatchHistory() bool { + if m != nil && m.Allow_3RdPartyMatchHistory != nil { + return *m.Allow_3RdPartyMatchHistory + } + return false +} + +type CMsgDOTASetMatchHistoryAccessResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASetMatchHistoryAccessResponse) Reset() { *m = CMsgDOTASetMatchHistoryAccessResponse{} } +func (m *CMsgDOTASetMatchHistoryAccessResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASetMatchHistoryAccessResponse) ProtoMessage() {} +func (*CMsgDOTASetMatchHistoryAccessResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{207} +} + +const Default_CMsgDOTASetMatchHistoryAccessResponse_Eresult uint32 = 2 + +func (m *CMsgDOTASetMatchHistoryAccessResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDOTASetMatchHistoryAccessResponse_Eresult +} + +type CMsgDOTANotifyAccountFlagsChange struct { + Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"` + AccountFlags *uint32 `protobuf:"varint,2,opt,name=account_flags" json:"account_flags,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTANotifyAccountFlagsChange) Reset() { *m = CMsgDOTANotifyAccountFlagsChange{} } +func (m *CMsgDOTANotifyAccountFlagsChange) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTANotifyAccountFlagsChange) ProtoMessage() {} +func (*CMsgDOTANotifyAccountFlagsChange) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{208} +} + +func (m *CMsgDOTANotifyAccountFlagsChange) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +func (m *CMsgDOTANotifyAccountFlagsChange) GetAccountFlags() uint32 { + if m != nil && m.AccountFlags != nil { + return *m.AccountFlags + } + return 0 +} + +type CMsgDOTASetProfilePrivacy struct { + ProfilePrivate *bool `protobuf:"varint,1,opt,name=profile_private" json:"profile_private,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASetProfilePrivacy) Reset() { *m = CMsgDOTASetProfilePrivacy{} } +func (m *CMsgDOTASetProfilePrivacy) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASetProfilePrivacy) ProtoMessage() {} +func (*CMsgDOTASetProfilePrivacy) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{209} } + +func (m *CMsgDOTASetProfilePrivacy) GetProfilePrivate() bool { + if m != nil && m.ProfilePrivate != nil { + return *m.ProfilePrivate + } + return false +} + +type CMsgDOTASetProfilePrivacyResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASetProfilePrivacyResponse) Reset() { *m = CMsgDOTASetProfilePrivacyResponse{} } +func (m *CMsgDOTASetProfilePrivacyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASetProfilePrivacyResponse) ProtoMessage() {} +func (*CMsgDOTASetProfilePrivacyResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{210} +} + +func (m *CMsgDOTASetProfilePrivacyResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgUpgradeLeagueItem struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgUpgradeLeagueItem) Reset() { *m = CMsgUpgradeLeagueItem{} } +func (m *CMsgUpgradeLeagueItem) String() string { return proto.CompactTextString(m) } +func (*CMsgUpgradeLeagueItem) ProtoMessage() {} +func (*CMsgUpgradeLeagueItem) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{211} } + +func (m *CMsgUpgradeLeagueItem) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgUpgradeLeagueItem) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CMsgUpgradeLeagueItemResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgUpgradeLeagueItemResponse) Reset() { *m = CMsgUpgradeLeagueItemResponse{} } +func (m *CMsgUpgradeLeagueItemResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgUpgradeLeagueItemResponse) ProtoMessage() {} +func (*CMsgUpgradeLeagueItemResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{212} } + +type CMsgGCWatchDownloadedReplay struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + WatchType *DOTA_WatchReplayType `protobuf:"varint,2,opt,name=watch_type,enum=DOTA_WatchReplayType,def=0" json:"watch_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCWatchDownloadedReplay) Reset() { *m = CMsgGCWatchDownloadedReplay{} } +func (m *CMsgGCWatchDownloadedReplay) String() string { return proto.CompactTextString(m) } +func (*CMsgGCWatchDownloadedReplay) ProtoMessage() {} +func (*CMsgGCWatchDownloadedReplay) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{213} } + +const Default_CMsgGCWatchDownloadedReplay_WatchType DOTA_WatchReplayType = DOTA_WatchReplayType_DOTA_WATCH_REPLAY_NORMAL + +func (m *CMsgGCWatchDownloadedReplay) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgGCWatchDownloadedReplay) GetWatchType() DOTA_WatchReplayType { + if m != nil && m.WatchType != nil { + return *m.WatchType + } + return Default_CMsgGCWatchDownloadedReplay_WatchType +} + +type CMsgSetMapLocationState struct { + LocationId *int32 `protobuf:"varint,1,opt,name=location_id" json:"location_id,omitempty"` + Completed *bool `protobuf:"varint,2,opt,name=completed" json:"completed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSetMapLocationState) Reset() { *m = CMsgSetMapLocationState{} } +func (m *CMsgSetMapLocationState) String() string { return proto.CompactTextString(m) } +func (*CMsgSetMapLocationState) ProtoMessage() {} +func (*CMsgSetMapLocationState) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{214} } + +func (m *CMsgSetMapLocationState) GetLocationId() int32 { + if m != nil && m.LocationId != nil { + return *m.LocationId + } + return 0 +} + +func (m *CMsgSetMapLocationState) GetCompleted() bool { + if m != nil && m.Completed != nil { + return *m.Completed + } + return false +} + +type CMsgSetMapLocationStateResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSetMapLocationStateResponse) Reset() { *m = CMsgSetMapLocationStateResponse{} } +func (m *CMsgSetMapLocationStateResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgSetMapLocationStateResponse) ProtoMessage() {} +func (*CMsgSetMapLocationStateResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{215} +} + +const Default_CMsgSetMapLocationStateResponse_Eresult uint32 = 2 + +func (m *CMsgSetMapLocationStateResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgSetMapLocationStateResponse_Eresult +} + +type CMsgResetMapLocations struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgResetMapLocations) Reset() { *m = CMsgResetMapLocations{} } +func (m *CMsgResetMapLocations) String() string { return proto.CompactTextString(m) } +func (*CMsgResetMapLocations) ProtoMessage() {} +func (*CMsgResetMapLocations) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{216} } + +type CMsgResetMapLocationsResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgResetMapLocationsResponse) Reset() { *m = CMsgResetMapLocationsResponse{} } +func (m *CMsgResetMapLocationsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgResetMapLocationsResponse) ProtoMessage() {} +func (*CMsgResetMapLocationsResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{217} } + +const Default_CMsgResetMapLocationsResponse_Eresult uint32 = 2 + +func (m *CMsgResetMapLocationsResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgResetMapLocationsResponse_Eresult +} + +type CMsgRefreshPartnerAccountLink struct { + PartnerType *int32 `protobuf:"varint,1,opt,name=partner_type" json:"partner_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRefreshPartnerAccountLink) Reset() { *m = CMsgRefreshPartnerAccountLink{} } +func (m *CMsgRefreshPartnerAccountLink) String() string { return proto.CompactTextString(m) } +func (*CMsgRefreshPartnerAccountLink) ProtoMessage() {} +func (*CMsgRefreshPartnerAccountLink) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{218} } + +func (m *CMsgRefreshPartnerAccountLink) GetPartnerType() int32 { + if m != nil && m.PartnerType != nil { + return *m.PartnerType + } + return 0 +} + +type CMsgClientsRejoinChatChannels struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientsRejoinChatChannels) Reset() { *m = CMsgClientsRejoinChatChannels{} } +func (m *CMsgClientsRejoinChatChannels) String() string { return proto.CompactTextString(m) } +func (*CMsgClientsRejoinChatChannels) ProtoMessage() {} +func (*CMsgClientsRejoinChatChannels) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{219} } + +type CMsgDOTASendFriendRecruits struct { + Recruits []uint32 `protobuf:"varint,1,rep,name=recruits" json:"recruits,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASendFriendRecruits) Reset() { *m = CMsgDOTASendFriendRecruits{} } +func (m *CMsgDOTASendFriendRecruits) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASendFriendRecruits) ProtoMessage() {} +func (*CMsgDOTASendFriendRecruits) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{220} } + +func (m *CMsgDOTASendFriendRecruits) GetRecruits() []uint32 { + if m != nil { + return m.Recruits + } + return nil +} + +type CMsgDOTAFriendRecruitsRequest struct { + AccountIds []uint32 `protobuf:"varint,1,rep,name=account_ids" json:"account_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFriendRecruitsRequest) Reset() { *m = CMsgDOTAFriendRecruitsRequest{} } +func (m *CMsgDOTAFriendRecruitsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFriendRecruitsRequest) ProtoMessage() {} +func (*CMsgDOTAFriendRecruitsRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{221} } + +func (m *CMsgDOTAFriendRecruitsRequest) GetAccountIds() []uint32 { + if m != nil { + return m.AccountIds + } + return nil +} + +type CMsgDOTAFriendRecruitsResponse struct { + Result *CMsgDOTAFriendRecruitsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFriendRecruitsResponse_EResult,def=0" json:"result,omitempty"` + Recruits []*CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus `protobuf:"bytes,2,rep,name=recruits" json:"recruits,omitempty"` + Recruiters []*CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus `protobuf:"bytes,3,rep,name=recruiters" json:"recruiters,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFriendRecruitsResponse) Reset() { *m = CMsgDOTAFriendRecruitsResponse{} } +func (m *CMsgDOTAFriendRecruitsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFriendRecruitsResponse) ProtoMessage() {} +func (*CMsgDOTAFriendRecruitsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{222} +} + +const Default_CMsgDOTAFriendRecruitsResponse_Result CMsgDOTAFriendRecruitsResponse_EResult = CMsgDOTAFriendRecruitsResponse_SUCCESS + +func (m *CMsgDOTAFriendRecruitsResponse) GetResult() CMsgDOTAFriendRecruitsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFriendRecruitsResponse_Result +} + +func (m *CMsgDOTAFriendRecruitsResponse) GetRecruits() []*CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus { + if m != nil { + return m.Recruits + } + return nil +} + +func (m *CMsgDOTAFriendRecruitsResponse) GetRecruiters() []*CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus { + if m != nil { + return m.Recruiters + } + return nil +} + +type CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Status *uint32 `protobuf:"varint,2,opt,name=status" json:"status,omitempty"` + LevelsEarned *uint32 `protobuf:"varint,3,opt,name=levels_earned" json:"levels_earned,omitempty"` + Bonus *bool `protobuf:"varint,4,opt,name=bonus" json:"bonus,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) Reset() { + *m = CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus{} +} +func (m *CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) ProtoMessage() {} +func (*CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{222, 0} +} + +func (m *CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +func (m *CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) GetLevelsEarned() uint32 { + if m != nil && m.LevelsEarned != nil { + return *m.LevelsEarned + } + return 0 +} + +func (m *CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus) GetBonus() bool { + if m != nil && m.Bonus != nil { + return *m.Bonus + } + return false +} + +type CMsgDOTAFriendRecruitInviteAcceptDecline struct { + Accepted *bool `protobuf:"varint,1,opt,name=accepted" json:"accepted,omitempty"` + AccountId *uint32 `protobuf:"varint,2,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFriendRecruitInviteAcceptDecline) Reset() { + *m = CMsgDOTAFriendRecruitInviteAcceptDecline{} +} +func (m *CMsgDOTAFriendRecruitInviteAcceptDecline) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFriendRecruitInviteAcceptDecline) ProtoMessage() {} +func (*CMsgDOTAFriendRecruitInviteAcceptDecline) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{223} +} + +func (m *CMsgDOTAFriendRecruitInviteAcceptDecline) GetAccepted() bool { + if m != nil && m.Accepted != nil { + return *m.Accepted + } + return false +} + +func (m *CMsgDOTAFriendRecruitInviteAcceptDecline) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgRequestLeaguePrizePool struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestLeaguePrizePool) Reset() { *m = CMsgRequestLeaguePrizePool{} } +func (m *CMsgRequestLeaguePrizePool) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestLeaguePrizePool) ProtoMessage() {} +func (*CMsgRequestLeaguePrizePool) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{224} } + +func (m *CMsgRequestLeaguePrizePool) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CMsgRequestLeaguePrizePoolResponse struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + PrizePool *uint32 `protobuf:"varint,2,opt,name=prize_pool" json:"prize_pool,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestLeaguePrizePoolResponse) Reset() { *m = CMsgRequestLeaguePrizePoolResponse{} } +func (m *CMsgRequestLeaguePrizePoolResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestLeaguePrizePoolResponse) ProtoMessage() {} +func (*CMsgRequestLeaguePrizePoolResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{225} +} + +func (m *CMsgRequestLeaguePrizePoolResponse) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgRequestLeaguePrizePoolResponse) GetPrizePool() uint32 { + if m != nil && m.PrizePool != nil { + return *m.PrizePool + } + return 0 +} + +type CMsgGCGetHeroStandings struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCGetHeroStandings) Reset() { *m = CMsgGCGetHeroStandings{} } +func (m *CMsgGCGetHeroStandings) String() string { return proto.CompactTextString(m) } +func (*CMsgGCGetHeroStandings) ProtoMessage() {} +func (*CMsgGCGetHeroStandings) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{226} } + +type CMsgGCGetHeroStandingsResponse struct { + Standings []*CMsgGCGetHeroStandingsResponse_Hero `protobuf:"bytes,1,rep,name=standings" json:"standings,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCGetHeroStandingsResponse) Reset() { *m = CMsgGCGetHeroStandingsResponse{} } +func (m *CMsgGCGetHeroStandingsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCGetHeroStandingsResponse) ProtoMessage() {} +func (*CMsgGCGetHeroStandingsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{227} +} + +func (m *CMsgGCGetHeroStandingsResponse) GetStandings() []*CMsgGCGetHeroStandingsResponse_Hero { + if m != nil { + return m.Standings + } + return nil +} + +type CMsgGCGetHeroStandingsResponse_Hero struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + Wins *uint32 `protobuf:"varint,2,opt,name=wins" json:"wins,omitempty"` + Losses *uint32 `protobuf:"varint,3,opt,name=losses" json:"losses,omitempty"` + WinStreak *uint32 `protobuf:"varint,4,opt,name=win_streak" json:"win_streak,omitempty"` + BestWinStreak *uint32 `protobuf:"varint,5,opt,name=best_win_streak" json:"best_win_streak,omitempty"` + AvgKills *float32 `protobuf:"fixed32,6,opt,name=avg_kills" json:"avg_kills,omitempty"` + AvgDeaths *float32 `protobuf:"fixed32,7,opt,name=avg_deaths" json:"avg_deaths,omitempty"` + AvgAssists *float32 `protobuf:"fixed32,8,opt,name=avg_assists" json:"avg_assists,omitempty"` + AvgGpm *float32 `protobuf:"fixed32,9,opt,name=avg_gpm" json:"avg_gpm,omitempty"` + AvgXpm *float32 `protobuf:"fixed32,10,opt,name=avg_xpm" json:"avg_xpm,omitempty"` + BestKills *uint32 `protobuf:"varint,11,opt,name=best_kills" json:"best_kills,omitempty"` + BestAssists *uint32 `protobuf:"varint,12,opt,name=best_assists" json:"best_assists,omitempty"` + BestGpm *uint32 `protobuf:"varint,13,opt,name=best_gpm" json:"best_gpm,omitempty"` + BestXpm *uint32 `protobuf:"varint,14,opt,name=best_xpm" json:"best_xpm,omitempty"` + Performance *float32 `protobuf:"fixed32,15,opt,name=performance" json:"performance,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) Reset() { *m = CMsgGCGetHeroStandingsResponse_Hero{} } +func (m *CMsgGCGetHeroStandingsResponse_Hero) String() string { return proto.CompactTextString(m) } +func (*CMsgGCGetHeroStandingsResponse_Hero) ProtoMessage() {} +func (*CMsgGCGetHeroStandingsResponse_Hero) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{227, 0} +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetWins() uint32 { + if m != nil && m.Wins != nil { + return *m.Wins + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetLosses() uint32 { + if m != nil && m.Losses != nil { + return *m.Losses + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetWinStreak() uint32 { + if m != nil && m.WinStreak != nil { + return *m.WinStreak + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetBestWinStreak() uint32 { + if m != nil && m.BestWinStreak != nil { + return *m.BestWinStreak + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetAvgKills() float32 { + if m != nil && m.AvgKills != nil { + return *m.AvgKills + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetAvgDeaths() float32 { + if m != nil && m.AvgDeaths != nil { + return *m.AvgDeaths + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetAvgAssists() float32 { + if m != nil && m.AvgAssists != nil { + return *m.AvgAssists + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetAvgGpm() float32 { + if m != nil && m.AvgGpm != nil { + return *m.AvgGpm + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetAvgXpm() float32 { + if m != nil && m.AvgXpm != nil { + return *m.AvgXpm + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetBestKills() uint32 { + if m != nil && m.BestKills != nil { + return *m.BestKills + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetBestAssists() uint32 { + if m != nil && m.BestAssists != nil { + return *m.BestAssists + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetBestGpm() uint32 { + if m != nil && m.BestGpm != nil { + return *m.BestGpm + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetBestXpm() uint32 { + if m != nil && m.BestXpm != nil { + return *m.BestXpm + } + return 0 +} + +func (m *CMsgGCGetHeroStandingsResponse_Hero) GetPerformance() float32 { + if m != nil && m.Performance != nil { + return *m.Performance + } + return 0 +} + +type CMsgGCItemEditorReservationsRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorReservationsRequest) Reset() { *m = CMsgGCItemEditorReservationsRequest{} } +func (m *CMsgGCItemEditorReservationsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorReservationsRequest) ProtoMessage() {} +func (*CMsgGCItemEditorReservationsRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{228} +} + +type CMsgGCItemEditorReservation struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorReservation) Reset() { *m = CMsgGCItemEditorReservation{} } +func (m *CMsgGCItemEditorReservation) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorReservation) ProtoMessage() {} +func (*CMsgGCItemEditorReservation) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{229} } + +func (m *CMsgGCItemEditorReservation) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CMsgGCItemEditorReservation) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type CMsgGCItemEditorReservationsResponse struct { + Reservations []*CMsgGCItemEditorReservation `protobuf:"bytes,1,rep,name=reservations" json:"reservations,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorReservationsResponse) Reset() { *m = CMsgGCItemEditorReservationsResponse{} } +func (m *CMsgGCItemEditorReservationsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorReservationsResponse) ProtoMessage() {} +func (*CMsgGCItemEditorReservationsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{230} +} + +func (m *CMsgGCItemEditorReservationsResponse) GetReservations() []*CMsgGCItemEditorReservation { + if m != nil { + return m.Reservations + } + return nil +} + +type CMsgGCItemEditorReserveItemDef struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + Username *string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorReserveItemDef) Reset() { *m = CMsgGCItemEditorReserveItemDef{} } +func (m *CMsgGCItemEditorReserveItemDef) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorReserveItemDef) ProtoMessage() {} +func (*CMsgGCItemEditorReserveItemDef) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{231} +} + +func (m *CMsgGCItemEditorReserveItemDef) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CMsgGCItemEditorReserveItemDef) GetUsername() string { + if m != nil && m.Username != nil { + return *m.Username + } + return "" +} + +type CMsgGCItemEditorReserveItemDefResponse struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + Username *string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"` + Result *uint32 `protobuf:"varint,3,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorReserveItemDefResponse) Reset() { + *m = CMsgGCItemEditorReserveItemDefResponse{} +} +func (m *CMsgGCItemEditorReserveItemDefResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorReserveItemDefResponse) ProtoMessage() {} +func (*CMsgGCItemEditorReserveItemDefResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{232} +} + +func (m *CMsgGCItemEditorReserveItemDefResponse) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CMsgGCItemEditorReserveItemDefResponse) GetUsername() string { + if m != nil && m.Username != nil { + return *m.Username + } + return "" +} + +func (m *CMsgGCItemEditorReserveItemDefResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgGCItemEditorReleaseReservation struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + Username *string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorReleaseReservation) Reset() { *m = CMsgGCItemEditorReleaseReservation{} } +func (m *CMsgGCItemEditorReleaseReservation) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorReleaseReservation) ProtoMessage() {} +func (*CMsgGCItemEditorReleaseReservation) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{233} +} + +func (m *CMsgGCItemEditorReleaseReservation) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CMsgGCItemEditorReleaseReservation) GetUsername() string { + if m != nil && m.Username != nil { + return *m.Username + } + return "" +} + +type CMsgGCItemEditorReleaseReservationResponse struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + Released *bool `protobuf:"varint,2,opt,name=released" json:"released,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorReleaseReservationResponse) Reset() { + *m = CMsgGCItemEditorReleaseReservationResponse{} +} +func (m *CMsgGCItemEditorReleaseReservationResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCItemEditorReleaseReservationResponse) ProtoMessage() {} +func (*CMsgGCItemEditorReleaseReservationResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{234} +} + +func (m *CMsgGCItemEditorReleaseReservationResponse) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CMsgGCItemEditorReleaseReservationResponse) GetReleased() bool { + if m != nil && m.Released != nil { + return *m.Released + } + return false +} + +type CMsgGCItemEditorRequestLeagueInfo struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorRequestLeagueInfo) Reset() { *m = CMsgGCItemEditorRequestLeagueInfo{} } +func (m *CMsgGCItemEditorRequestLeagueInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorRequestLeagueInfo) ProtoMessage() {} +func (*CMsgGCItemEditorRequestLeagueInfo) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{235} +} + +func (m *CMsgGCItemEditorRequestLeagueInfo) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CMsgGCItemEditorLeagueInfoResponse struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + LeagueName *string `protobuf:"bytes,2,opt,name=league_name" json:"league_name,omitempty"` + LeagueDesc *string `protobuf:"bytes,3,opt,name=league_desc" json:"league_desc,omitempty"` + LeagueUrl *string `protobuf:"bytes,4,opt,name=league_url" json:"league_url,omitempty"` + RevenueUrl *string `protobuf:"bytes,5,opt,name=revenue_url" json:"revenue_url,omitempty"` + Tier *uint32 `protobuf:"varint,6,opt,name=tier" json:"tier,omitempty"` + Location *uint32 `protobuf:"varint,7,opt,name=location" json:"location,omitempty"` + Result *uint32 `protobuf:"varint,8,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) Reset() { *m = CMsgGCItemEditorLeagueInfoResponse{} } +func (m *CMsgGCItemEditorLeagueInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCItemEditorLeagueInfoResponse) ProtoMessage() {} +func (*CMsgGCItemEditorLeagueInfoResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{236} +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetLeagueName() string { + if m != nil && m.LeagueName != nil { + return *m.LeagueName + } + return "" +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetLeagueDesc() string { + if m != nil && m.LeagueDesc != nil { + return *m.LeagueDesc + } + return "" +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetLeagueUrl() string { + if m != nil && m.LeagueUrl != nil { + return *m.LeagueUrl + } + return "" +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetRevenueUrl() string { + if m != nil && m.RevenueUrl != nil { + return *m.RevenueUrl + } + return "" +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetTier() uint32 { + if m != nil && m.Tier != nil { + return *m.Tier + } + return 0 +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetLocation() uint32 { + if m != nil && m.Location != nil { + return *m.Location + } + return 0 +} + +func (m *CMsgGCItemEditorLeagueInfoResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgDOTARewardTutorialPrizes struct { + LocationId *uint32 `protobuf:"varint,1,opt,name=location_id" json:"location_id,omitempty"` + TrackingOnly *bool `protobuf:"varint,2,opt,name=tracking_only" json:"tracking_only,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARewardTutorialPrizes) Reset() { *m = CMsgDOTARewardTutorialPrizes{} } +func (m *CMsgDOTARewardTutorialPrizes) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARewardTutorialPrizes) ProtoMessage() {} +func (*CMsgDOTARewardTutorialPrizes) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{237} } + +func (m *CMsgDOTARewardTutorialPrizes) GetLocationId() uint32 { + if m != nil && m.LocationId != nil { + return *m.LocationId + } + return 0 +} + +func (m *CMsgDOTARewardTutorialPrizes) GetTrackingOnly() bool { + if m != nil && m.TrackingOnly != nil { + return *m.TrackingOnly + } + return false +} + +type CMsgDOTALastHitChallengeHighScorePost struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + HighScore *uint32 `protobuf:"varint,2,opt,name=high_score" json:"high_score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALastHitChallengeHighScorePost) Reset() { *m = CMsgDOTALastHitChallengeHighScorePost{} } +func (m *CMsgDOTALastHitChallengeHighScorePost) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALastHitChallengeHighScorePost) ProtoMessage() {} +func (*CMsgDOTALastHitChallengeHighScorePost) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{238} +} + +func (m *CMsgDOTALastHitChallengeHighScorePost) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTALastHitChallengeHighScorePost) GetHighScore() uint32 { + if m != nil && m.HighScore != nil { + return *m.HighScore + } + return 0 +} + +type CMsgDOTALastHitChallengeHighScoreRequest struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALastHitChallengeHighScoreRequest) Reset() { + *m = CMsgDOTALastHitChallengeHighScoreRequest{} +} +func (m *CMsgDOTALastHitChallengeHighScoreRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALastHitChallengeHighScoreRequest) ProtoMessage() {} +func (*CMsgDOTALastHitChallengeHighScoreRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{239} +} + +func (m *CMsgDOTALastHitChallengeHighScoreRequest) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgDOTALastHitChallengeHighScoreResponse struct { + Score *uint32 `protobuf:"varint,1,opt,name=score" json:"score,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALastHitChallengeHighScoreResponse) Reset() { + *m = CMsgDOTALastHitChallengeHighScoreResponse{} +} +func (m *CMsgDOTALastHitChallengeHighScoreResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALastHitChallengeHighScoreResponse) ProtoMessage() {} +func (*CMsgDOTALastHitChallengeHighScoreResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{240} +} + +func (m *CMsgDOTALastHitChallengeHighScoreResponse) GetScore() uint32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *CMsgDOTALastHitChallengeHighScoreResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgFlipLobbyTeams struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFlipLobbyTeams) Reset() { *m = CMsgFlipLobbyTeams{} } +func (m *CMsgFlipLobbyTeams) String() string { return proto.CompactTextString(m) } +func (*CMsgFlipLobbyTeams) ProtoMessage() {} +func (*CMsgFlipLobbyTeams) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{241} } + +type CMsgPresentedClientTerminateDlg struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPresentedClientTerminateDlg) Reset() { *m = CMsgPresentedClientTerminateDlg{} } +func (m *CMsgPresentedClientTerminateDlg) String() string { return proto.CompactTextString(m) } +func (*CMsgPresentedClientTerminateDlg) ProtoMessage() {} +func (*CMsgPresentedClientTerminateDlg) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{242} +} + +type CMsgGCLobbyUpdateBroadcastChannelInfo struct { + ChannelId *uint32 `protobuf:"varint,1,opt,name=channel_id" json:"channel_id,omitempty"` + CountryCode *string `protobuf:"bytes,2,opt,name=country_code" json:"country_code,omitempty"` + Description *string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"` + LanguageCode *string `protobuf:"bytes,4,opt,name=language_code" json:"language_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCLobbyUpdateBroadcastChannelInfo) Reset() { *m = CMsgGCLobbyUpdateBroadcastChannelInfo{} } +func (m *CMsgGCLobbyUpdateBroadcastChannelInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgGCLobbyUpdateBroadcastChannelInfo) ProtoMessage() {} +func (*CMsgGCLobbyUpdateBroadcastChannelInfo) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{243} +} + +func (m *CMsgGCLobbyUpdateBroadcastChannelInfo) GetChannelId() uint32 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CMsgGCLobbyUpdateBroadcastChannelInfo) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgGCLobbyUpdateBroadcastChannelInfo) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CMsgGCLobbyUpdateBroadcastChannelInfo) GetLanguageCode() string { + if m != nil && m.LanguageCode != nil { + return *m.LanguageCode + } + return "" +} + +type CMsgDOTARedeemEventPrize struct { + PrizeId *uint32 `protobuf:"varint,1,opt,name=prize_id" json:"prize_id,omitempty"` + EventId *uint32 `protobuf:"varint,2,opt,name=event_id" json:"event_id,omitempty"` + Quantity *uint32 `protobuf:"varint,3,opt,name=quantity,def=1" json:"quantity,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARedeemEventPrize) Reset() { *m = CMsgDOTARedeemEventPrize{} } +func (m *CMsgDOTARedeemEventPrize) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARedeemEventPrize) ProtoMessage() {} +func (*CMsgDOTARedeemEventPrize) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{244} } + +const Default_CMsgDOTARedeemEventPrize_Quantity uint32 = 1 + +func (m *CMsgDOTARedeemEventPrize) GetPrizeId() uint32 { + if m != nil && m.PrizeId != nil { + return *m.PrizeId + } + return 0 +} + +func (m *CMsgDOTARedeemEventPrize) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CMsgDOTARedeemEventPrize) GetQuantity() uint32 { + if m != nil && m.Quantity != nil { + return *m.Quantity + } + return Default_CMsgDOTARedeemEventPrize_Quantity +} + +type CMsgDOTARedeemEventPrizeResponse struct { + Result *CMsgDOTARedeemEventPrizeResponse_ResultCode `protobuf:"varint,1,opt,name=result,enum=CMsgDOTARedeemEventPrizeResponse_ResultCode,def=0" json:"result,omitempty"` + RemainingPoints *uint32 `protobuf:"varint,2,opt,name=remaining_points" json:"remaining_points,omitempty"` + RemainingPremiumPoints *uint32 `protobuf:"varint,3,opt,name=remaining_premium_points" json:"remaining_premium_points,omitempty"` + EventId *uint32 `protobuf:"varint,4,opt,name=event_id" json:"event_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARedeemEventPrizeResponse) Reset() { *m = CMsgDOTARedeemEventPrizeResponse{} } +func (m *CMsgDOTARedeemEventPrizeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARedeemEventPrizeResponse) ProtoMessage() {} +func (*CMsgDOTARedeemEventPrizeResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{245} +} + +const Default_CMsgDOTARedeemEventPrizeResponse_Result CMsgDOTARedeemEventPrizeResponse_ResultCode = CMsgDOTARedeemEventPrizeResponse_Success + +func (m *CMsgDOTARedeemEventPrizeResponse) GetResult() CMsgDOTARedeemEventPrizeResponse_ResultCode { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTARedeemEventPrizeResponse_Result +} + +func (m *CMsgDOTARedeemEventPrizeResponse) GetRemainingPoints() uint32 { + if m != nil && m.RemainingPoints != nil { + return *m.RemainingPoints + } + return 0 +} + +func (m *CMsgDOTARedeemEventPrizeResponse) GetRemainingPremiumPoints() uint32 { + if m != nil && m.RemainingPremiumPoints != nil { + return *m.RemainingPremiumPoints + } + return 0 +} + +func (m *CMsgDOTARedeemEventPrizeResponse) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +type CMsgDOTAGetEventPoints struct { + EventId *uint32 `protobuf:"varint,1,opt,name=event_id" json:"event_id,omitempty"` + AccountId *uint32 `protobuf:"varint,2,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGetEventPoints) Reset() { *m = CMsgDOTAGetEventPoints{} } +func (m *CMsgDOTAGetEventPoints) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGetEventPoints) ProtoMessage() {} +func (*CMsgDOTAGetEventPoints) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{246} } + +func (m *CMsgDOTAGetEventPoints) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CMsgDOTAGetEventPoints) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgDOTAGetEventPointsResponse struct { + TotalPoints *uint32 `protobuf:"varint,1,opt,name=total_points" json:"total_points,omitempty"` + TotalPremiumPoints *uint32 `protobuf:"varint,2,opt,name=total_premium_points" json:"total_premium_points,omitempty"` + EventId *uint32 `protobuf:"varint,3,opt,name=event_id" json:"event_id,omitempty"` + Points *uint32 `protobuf:"varint,4,opt,name=points" json:"points,omitempty"` + PremiumPoints *uint32 `protobuf:"varint,5,opt,name=premium_points" json:"premium_points,omitempty"` + CompletedActions []*CMsgDOTAGetEventPointsResponse_Action `protobuf:"bytes,6,rep,name=completed_actions" json:"completed_actions,omitempty"` + AccountId *uint32 `protobuf:"varint,7,opt,name=account_id" json:"account_id,omitempty"` + Owned *bool `protobuf:"varint,8,opt,name=owned" json:"owned,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGetEventPointsResponse) Reset() { *m = CMsgDOTAGetEventPointsResponse{} } +func (m *CMsgDOTAGetEventPointsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGetEventPointsResponse) ProtoMessage() {} +func (*CMsgDOTAGetEventPointsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{247} +} + +func (m *CMsgDOTAGetEventPointsResponse) GetTotalPoints() uint32 { + if m != nil && m.TotalPoints != nil { + return *m.TotalPoints + } + return 0 +} + +func (m *CMsgDOTAGetEventPointsResponse) GetTotalPremiumPoints() uint32 { + if m != nil && m.TotalPremiumPoints != nil { + return *m.TotalPremiumPoints + } + return 0 +} + +func (m *CMsgDOTAGetEventPointsResponse) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CMsgDOTAGetEventPointsResponse) GetPoints() uint32 { + if m != nil && m.Points != nil { + return *m.Points + } + return 0 +} + +func (m *CMsgDOTAGetEventPointsResponse) GetPremiumPoints() uint32 { + if m != nil && m.PremiumPoints != nil { + return *m.PremiumPoints + } + return 0 +} + +func (m *CMsgDOTAGetEventPointsResponse) GetCompletedActions() []*CMsgDOTAGetEventPointsResponse_Action { + if m != nil { + return m.CompletedActions + } + return nil +} + +func (m *CMsgDOTAGetEventPointsResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAGetEventPointsResponse) GetOwned() bool { + if m != nil && m.Owned != nil { + return *m.Owned + } + return false +} + +type CMsgDOTAGetEventPointsResponse_Action struct { + ActionId *uint32 `protobuf:"varint,1,opt,name=action_id" json:"action_id,omitempty"` + TimesCompleted *uint32 `protobuf:"varint,2,opt,name=times_completed,def=1" json:"times_completed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGetEventPointsResponse_Action) Reset() { *m = CMsgDOTAGetEventPointsResponse_Action{} } +func (m *CMsgDOTAGetEventPointsResponse_Action) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGetEventPointsResponse_Action) ProtoMessage() {} +func (*CMsgDOTAGetEventPointsResponse_Action) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{247, 0} +} + +const Default_CMsgDOTAGetEventPointsResponse_Action_TimesCompleted uint32 = 1 + +func (m *CMsgDOTAGetEventPointsResponse_Action) GetActionId() uint32 { + if m != nil && m.ActionId != nil { + return *m.ActionId + } + return 0 +} + +func (m *CMsgDOTAGetEventPointsResponse_Action) GetTimesCompleted() uint32 { + if m != nil && m.TimesCompleted != nil { + return *m.TimesCompleted + } + return Default_CMsgDOTAGetEventPointsResponse_Action_TimesCompleted +} + +type CMsgDOTALiveLeagueGameUpdate struct { + LiveLeagueGames *uint32 `protobuf:"varint,1,opt,name=live_league_games" json:"live_league_games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALiveLeagueGameUpdate) Reset() { *m = CMsgDOTALiveLeagueGameUpdate{} } +func (m *CMsgDOTALiveLeagueGameUpdate) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALiveLeagueGameUpdate) ProtoMessage() {} +func (*CMsgDOTALiveLeagueGameUpdate) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{248} } + +func (m *CMsgDOTALiveLeagueGameUpdate) GetLiveLeagueGames() uint32 { + if m != nil && m.LiveLeagueGames != nil { + return *m.LiveLeagueGames + } + return 0 +} + +type CMsgDOTACompendiumSelection struct { + SelectionIndex *uint32 `protobuf:"varint,1,opt,name=selection_index" json:"selection_index,omitempty"` + Selection *uint32 `protobuf:"varint,2,opt,name=selection" json:"selection,omitempty"` + Leagueid *uint32 `protobuf:"varint,3,opt,name=leagueid" json:"leagueid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACompendiumSelection) Reset() { *m = CMsgDOTACompendiumSelection{} } +func (m *CMsgDOTACompendiumSelection) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACompendiumSelection) ProtoMessage() {} +func (*CMsgDOTACompendiumSelection) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{249} } + +func (m *CMsgDOTACompendiumSelection) GetSelectionIndex() uint32 { + if m != nil && m.SelectionIndex != nil { + return *m.SelectionIndex + } + return 0 +} + +func (m *CMsgDOTACompendiumSelection) GetSelection() uint32 { + if m != nil && m.Selection != nil { + return *m.Selection + } + return 0 +} + +func (m *CMsgDOTACompendiumSelection) GetLeagueid() uint32 { + if m != nil && m.Leagueid != nil { + return *m.Leagueid + } + return 0 +} + +type CMsgDOTACompendiumSelectionResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + ExtraSelections []*CMsgDOTACompendiumSelection `protobuf:"bytes,2,rep,name=extra_selections" json:"extra_selections,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACompendiumSelectionResponse) Reset() { *m = CMsgDOTACompendiumSelectionResponse{} } +func (m *CMsgDOTACompendiumSelectionResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACompendiumSelectionResponse) ProtoMessage() {} +func (*CMsgDOTACompendiumSelectionResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{250} +} + +const Default_CMsgDOTACompendiumSelectionResponse_Eresult uint32 = 2 + +func (m *CMsgDOTACompendiumSelectionResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDOTACompendiumSelectionResponse_Eresult +} + +func (m *CMsgDOTACompendiumSelectionResponse) GetExtraSelections() []*CMsgDOTACompendiumSelection { + if m != nil { + return m.ExtraSelections + } + return nil +} + +type CMsgDOTACompendiumData struct { + Selections []*CMsgDOTACompendiumSelection `protobuf:"bytes,1,rep,name=selections" json:"selections,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACompendiumData) Reset() { *m = CMsgDOTACompendiumData{} } +func (m *CMsgDOTACompendiumData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACompendiumData) ProtoMessage() {} +func (*CMsgDOTACompendiumData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{251} } + +func (m *CMsgDOTACompendiumData) GetSelections() []*CMsgDOTACompendiumSelection { + if m != nil { + return m.Selections + } + return nil +} + +type CMsgDOTACompendiumDataRequest struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Leagueid *uint32 `protobuf:"varint,2,opt,name=leagueid" json:"leagueid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACompendiumDataRequest) Reset() { *m = CMsgDOTACompendiumDataRequest{} } +func (m *CMsgDOTACompendiumDataRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACompendiumDataRequest) ProtoMessage() {} +func (*CMsgDOTACompendiumDataRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{252} } + +func (m *CMsgDOTACompendiumDataRequest) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTACompendiumDataRequest) GetLeagueid() uint32 { + if m != nil && m.Leagueid != nil { + return *m.Leagueid + } + return 0 +} + +type CMsgDOTACompendiumDataResponse struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Leagueid *uint32 `protobuf:"varint,2,opt,name=leagueid" json:"leagueid,omitempty"` + Result *uint32 `protobuf:"varint,3,opt,name=result,def=2" json:"result,omitempty"` + CompendiumData *CMsgDOTACompendiumData `protobuf:"bytes,4,opt,name=compendium_data" json:"compendium_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACompendiumDataResponse) Reset() { *m = CMsgDOTACompendiumDataResponse{} } +func (m *CMsgDOTACompendiumDataResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACompendiumDataResponse) ProtoMessage() {} +func (*CMsgDOTACompendiumDataResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{253} +} + +const Default_CMsgDOTACompendiumDataResponse_Result uint32 = 2 + +func (m *CMsgDOTACompendiumDataResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTACompendiumDataResponse) GetLeagueid() uint32 { + if m != nil && m.Leagueid != nil { + return *m.Leagueid + } + return 0 +} + +func (m *CMsgDOTACompendiumDataResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTACompendiumDataResponse_Result +} + +func (m *CMsgDOTACompendiumDataResponse) GetCompendiumData() *CMsgDOTACompendiumData { + if m != nil { + return m.CompendiumData + } + return nil +} + +type CMsgDOTAGetPlayerMatchHistory struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + StartAtMatchId *uint64 `protobuf:"varint,2,opt,name=start_at_match_id" json:"start_at_match_id,omitempty"` + MatchesRequested *uint32 `protobuf:"varint,3,opt,name=matches_requested" json:"matches_requested,omitempty"` + HeroId *uint32 `protobuf:"varint,4,opt,name=hero_id" json:"hero_id,omitempty"` + RequestId *uint32 `protobuf:"varint,5,opt,name=request_id" json:"request_id,omitempty"` + IncludePracticeMatches *bool `protobuf:"varint,7,opt,name=include_practice_matches" json:"include_practice_matches,omitempty"` + IncludeCustomGames *bool `protobuf:"varint,8,opt,name=include_custom_games" json:"include_custom_games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGetPlayerMatchHistory) Reset() { *m = CMsgDOTAGetPlayerMatchHistory{} } +func (m *CMsgDOTAGetPlayerMatchHistory) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGetPlayerMatchHistory) ProtoMessage() {} +func (*CMsgDOTAGetPlayerMatchHistory) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{254} } + +func (m *CMsgDOTAGetPlayerMatchHistory) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistory) GetStartAtMatchId() uint64 { + if m != nil && m.StartAtMatchId != nil { + return *m.StartAtMatchId + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistory) GetMatchesRequested() uint32 { + if m != nil && m.MatchesRequested != nil { + return *m.MatchesRequested + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistory) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistory) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistory) GetIncludePracticeMatches() bool { + if m != nil && m.IncludePracticeMatches != nil { + return *m.IncludePracticeMatches + } + return false +} + +func (m *CMsgDOTAGetPlayerMatchHistory) GetIncludeCustomGames() bool { + if m != nil && m.IncludeCustomGames != nil { + return *m.IncludeCustomGames + } + return false +} + +type CMsgDOTAGetPlayerMatchHistoryResponse struct { + Matches []*CMsgDOTAGetPlayerMatchHistoryResponse_Match `protobuf:"bytes,1,rep,name=matches" json:"matches,omitempty"` + RequestId *uint32 `protobuf:"varint,2,opt,name=request_id" json:"request_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse) Reset() { *m = CMsgDOTAGetPlayerMatchHistoryResponse{} } +func (m *CMsgDOTAGetPlayerMatchHistoryResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGetPlayerMatchHistoryResponse) ProtoMessage() {} +func (*CMsgDOTAGetPlayerMatchHistoryResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{255} +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse) GetMatches() []*CMsgDOTAGetPlayerMatchHistoryResponse_Match { + if m != nil { + return m.Matches + } + return nil +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse) GetRequestId() uint32 { + if m != nil && m.RequestId != nil { + return *m.RequestId + } + return 0 +} + +type CMsgDOTAGetPlayerMatchHistoryResponse_Match struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + StartTime *uint32 `protobuf:"varint,2,opt,name=start_time" json:"start_time,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + Winner *bool `protobuf:"varint,4,opt,name=winner" json:"winner,omitempty"` + GameMode *uint32 `protobuf:"varint,5,opt,name=game_mode" json:"game_mode,omitempty"` + RankChange *int32 `protobuf:"varint,6,opt,name=rank_change" json:"rank_change,omitempty"` + PreviousRank *uint32 `protobuf:"varint,7,opt,name=previous_rank" json:"previous_rank,omitempty"` + LobbyType *uint32 `protobuf:"varint,8,opt,name=lobby_type" json:"lobby_type,omitempty"` + SoloRank *bool `protobuf:"varint,9,opt,name=solo_rank" json:"solo_rank,omitempty"` + Abandon *bool `protobuf:"varint,10,opt,name=abandon" json:"abandon,omitempty"` + Duration *uint32 `protobuf:"varint,11,opt,name=duration" json:"duration,omitempty"` + Engine *uint32 `protobuf:"varint,12,opt,name=engine" json:"engine,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) Reset() { + *m = CMsgDOTAGetPlayerMatchHistoryResponse_Match{} +} +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAGetPlayerMatchHistoryResponse_Match) ProtoMessage() {} +func (*CMsgDOTAGetPlayerMatchHistoryResponse_Match) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{255, 0} +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetWinner() bool { + if m != nil && m.Winner != nil { + return *m.Winner + } + return false +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetRankChange() int32 { + if m != nil && m.RankChange != nil { + return *m.RankChange + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetPreviousRank() uint32 { + if m != nil && m.PreviousRank != nil { + return *m.PreviousRank + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetLobbyType() uint32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetSoloRank() bool { + if m != nil && m.SoloRank != nil { + return *m.SoloRank + } + return false +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetAbandon() bool { + if m != nil && m.Abandon != nil { + return *m.Abandon + } + return false +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetDuration() uint32 { + if m != nil && m.Duration != nil { + return *m.Duration + } + return 0 +} + +func (m *CMsgDOTAGetPlayerMatchHistoryResponse_Match) GetEngine() uint32 { + if m != nil && m.Engine != nil { + return *m.Engine + } + return 0 +} + +type CMsgDOTAStartDailyHeroChallenge struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAStartDailyHeroChallenge) Reset() { *m = CMsgDOTAStartDailyHeroChallenge{} } +func (m *CMsgDOTAStartDailyHeroChallenge) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAStartDailyHeroChallenge) ProtoMessage() {} +func (*CMsgDOTAStartDailyHeroChallenge) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{256} +} + +type CMsgGCNotificationsRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCNotificationsRequest) Reset() { *m = CMsgGCNotificationsRequest{} } +func (m *CMsgGCNotificationsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCNotificationsRequest) ProtoMessage() {} +func (*CMsgGCNotificationsRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{257} } + +type CMsgGCNotificationsResponse struct { + Result *CMsgGCNotificationsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgGCNotificationsResponse_EResult,def=0" json:"result,omitempty"` + Notifications []*CMsgGCNotificationsResponse_Notification `protobuf:"bytes,2,rep,name=notifications" json:"notifications,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCNotificationsResponse) Reset() { *m = CMsgGCNotificationsResponse{} } +func (m *CMsgGCNotificationsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCNotificationsResponse) ProtoMessage() {} +func (*CMsgGCNotificationsResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{258} } + +const Default_CMsgGCNotificationsResponse_Result CMsgGCNotificationsResponse_EResult = CMsgGCNotificationsResponse_SUCCESS + +func (m *CMsgGCNotificationsResponse) GetResult() CMsgGCNotificationsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgGCNotificationsResponse_Result +} + +func (m *CMsgGCNotificationsResponse) GetNotifications() []*CMsgGCNotificationsResponse_Notification { + if m != nil { + return m.Notifications + } + return nil +} + +type CMsgGCNotificationsResponse_Notification struct { + Id *uint64 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"` + Type *uint32 `protobuf:"varint,2,opt,name=type" json:"type,omitempty"` + Timestamp *uint32 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` + ReferenceA *uint32 `protobuf:"varint,4,opt,name=reference_a" json:"reference_a,omitempty"` + ReferenceB *uint32 `protobuf:"varint,5,opt,name=reference_b" json:"reference_b,omitempty"` + ReferenceC *uint32 `protobuf:"varint,6,opt,name=reference_c" json:"reference_c,omitempty"` + Message *string `protobuf:"bytes,7,opt,name=message" json:"message,omitempty"` + Unread *bool `protobuf:"varint,8,opt,name=unread" json:"unread,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCNotificationsResponse_Notification) Reset() { + *m = CMsgGCNotificationsResponse_Notification{} +} +func (m *CMsgGCNotificationsResponse_Notification) String() string { return proto.CompactTextString(m) } +func (*CMsgGCNotificationsResponse_Notification) ProtoMessage() {} +func (*CMsgGCNotificationsResponse_Notification) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{258, 0} +} + +func (m *CMsgGCNotificationsResponse_Notification) GetId() uint64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CMsgGCNotificationsResponse_Notification) GetType() uint32 { + if m != nil && m.Type != nil { + return *m.Type + } + return 0 +} + +func (m *CMsgGCNotificationsResponse_Notification) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgGCNotificationsResponse_Notification) GetReferenceA() uint32 { + if m != nil && m.ReferenceA != nil { + return *m.ReferenceA + } + return 0 +} + +func (m *CMsgGCNotificationsResponse_Notification) GetReferenceB() uint32 { + if m != nil && m.ReferenceB != nil { + return *m.ReferenceB + } + return 0 +} + +func (m *CMsgGCNotificationsResponse_Notification) GetReferenceC() uint32 { + if m != nil && m.ReferenceC != nil { + return *m.ReferenceC + } + return 0 +} + +func (m *CMsgGCNotificationsResponse_Notification) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgGCNotificationsResponse_Notification) GetUnread() bool { + if m != nil && m.Unread != nil { + return *m.Unread + } + return false +} + +type CMsgGCNotificationsMarkReadRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCNotificationsMarkReadRequest) Reset() { *m = CMsgGCNotificationsMarkReadRequest{} } +func (m *CMsgGCNotificationsMarkReadRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCNotificationsMarkReadRequest) ProtoMessage() {} +func (*CMsgGCNotificationsMarkReadRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{259} +} + +type CMsgClientToGCMarkNotificationListRead struct { + NotificationIds []uint64 `protobuf:"varint,1,rep,name=notification_ids" json:"notification_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCMarkNotificationListRead) Reset() { + *m = CMsgClientToGCMarkNotificationListRead{} +} +func (m *CMsgClientToGCMarkNotificationListRead) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCMarkNotificationListRead) ProtoMessage() {} +func (*CMsgClientToGCMarkNotificationListRead) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{260} +} + +func (m *CMsgClientToGCMarkNotificationListRead) GetNotificationIds() []uint64 { + if m != nil { + return m.NotificationIds + } + return nil +} + +type CMsgGCLeagueAdminState struct { + Leagues []uint32 `protobuf:"varint,1,rep,name=leagues" json:"leagues,omitempty"` + Keys []*CMsgGCLeagueAdminState_PrivateLeagueKeys `protobuf:"bytes,2,rep,name=keys" json:"keys,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCLeagueAdminState) Reset() { *m = CMsgGCLeagueAdminState{} } +func (m *CMsgGCLeagueAdminState) String() string { return proto.CompactTextString(m) } +func (*CMsgGCLeagueAdminState) ProtoMessage() {} +func (*CMsgGCLeagueAdminState) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{261} } + +func (m *CMsgGCLeagueAdminState) GetLeagues() []uint32 { + if m != nil { + return m.Leagues + } + return nil +} + +func (m *CMsgGCLeagueAdminState) GetKeys() []*CMsgGCLeagueAdminState_PrivateLeagueKeys { + if m != nil { + return m.Keys + } + return nil +} + +type CMsgGCLeagueAdminState_PrivateLeagueKeys struct { + Leagueid *uint32 `protobuf:"varint,1,opt,name=leagueid" json:"leagueid,omitempty"` + Privatekey *uint32 `protobuf:"varint,2,opt,name=privatekey" json:"privatekey,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCLeagueAdminState_PrivateLeagueKeys) Reset() { + *m = CMsgGCLeagueAdminState_PrivateLeagueKeys{} +} +func (m *CMsgGCLeagueAdminState_PrivateLeagueKeys) String() string { return proto.CompactTextString(m) } +func (*CMsgGCLeagueAdminState_PrivateLeagueKeys) ProtoMessage() {} +func (*CMsgGCLeagueAdminState_PrivateLeagueKeys) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{261, 0} +} + +func (m *CMsgGCLeagueAdminState_PrivateLeagueKeys) GetLeagueid() uint32 { + if m != nil && m.Leagueid != nil { + return *m.Leagueid + } + return 0 +} + +func (m *CMsgGCLeagueAdminState_PrivateLeagueKeys) GetPrivatekey() uint32 { + if m != nil && m.Privatekey != nil { + return *m.Privatekey + } + return 0 +} + +type CMsgGCPlayerInfoRequest struct { + AccountIds []uint32 `protobuf:"varint,1,rep,name=account_ids" json:"account_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPlayerInfoRequest) Reset() { *m = CMsgGCPlayerInfoRequest{} } +func (m *CMsgGCPlayerInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPlayerInfoRequest) ProtoMessage() {} +func (*CMsgGCPlayerInfoRequest) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{262} } + +func (m *CMsgGCPlayerInfoRequest) GetAccountIds() []uint32 { + if m != nil { + return m.AccountIds + } + return nil +} + +type CMsgGCPlayerInfoSubmit struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + CountryCode *string `protobuf:"bytes,2,opt,name=country_code" json:"country_code,omitempty"` + FantasyRole *uint32 `protobuf:"varint,3,opt,name=fantasy_role" json:"fantasy_role,omitempty"` + TeamId *uint32 `protobuf:"varint,4,opt,name=team_id" json:"team_id,omitempty"` + Sponsor *string `protobuf:"bytes,5,opt,name=sponsor" json:"sponsor,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPlayerInfoSubmit) Reset() { *m = CMsgGCPlayerInfoSubmit{} } +func (m *CMsgGCPlayerInfoSubmit) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPlayerInfoSubmit) ProtoMessage() {} +func (*CMsgGCPlayerInfoSubmit) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{263} } + +func (m *CMsgGCPlayerInfoSubmit) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgGCPlayerInfoSubmit) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgGCPlayerInfoSubmit) GetFantasyRole() uint32 { + if m != nil && m.FantasyRole != nil { + return *m.FantasyRole + } + return 0 +} + +func (m *CMsgGCPlayerInfoSubmit) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgGCPlayerInfoSubmit) GetSponsor() string { + if m != nil && m.Sponsor != nil { + return *m.Sponsor + } + return "" +} + +type CMsgGCPlayerInfoSubmitResponse struct { + Result *CMsgGCPlayerInfoSubmitResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgGCPlayerInfoSubmitResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPlayerInfoSubmitResponse) Reset() { *m = CMsgGCPlayerInfoSubmitResponse{} } +func (m *CMsgGCPlayerInfoSubmitResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPlayerInfoSubmitResponse) ProtoMessage() {} +func (*CMsgGCPlayerInfoSubmitResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{264} +} + +const Default_CMsgGCPlayerInfoSubmitResponse_Result CMsgGCPlayerInfoSubmitResponse_EResult = CMsgGCPlayerInfoSubmitResponse_SUCCESS + +func (m *CMsgGCPlayerInfoSubmitResponse) GetResult() CMsgGCPlayerInfoSubmitResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgGCPlayerInfoSubmitResponse_Result +} + +type CMsgSerializedSOCache struct { + FileVersion *uint32 `protobuf:"varint,1,opt,name=file_version" json:"file_version,omitempty"` + Caches []*CMsgSerializedSOCache_Cache `protobuf:"bytes,2,rep,name=caches" json:"caches,omitempty"` + GcSocacheFileVersion *uint32 `protobuf:"varint,3,opt,name=gc_socache_file_version" json:"gc_socache_file_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSerializedSOCache) Reset() { *m = CMsgSerializedSOCache{} } +func (m *CMsgSerializedSOCache) String() string { return proto.CompactTextString(m) } +func (*CMsgSerializedSOCache) ProtoMessage() {} +func (*CMsgSerializedSOCache) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{265} } + +func (m *CMsgSerializedSOCache) GetFileVersion() uint32 { + if m != nil && m.FileVersion != nil { + return *m.FileVersion + } + return 0 +} + +func (m *CMsgSerializedSOCache) GetCaches() []*CMsgSerializedSOCache_Cache { + if m != nil { + return m.Caches + } + return nil +} + +func (m *CMsgSerializedSOCache) GetGcSocacheFileVersion() uint32 { + if m != nil && m.GcSocacheFileVersion != nil { + return *m.GcSocacheFileVersion + } + return 0 +} + +type CMsgSerializedSOCache_TypeCache struct { + Type *uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Objects [][]byte `protobuf:"bytes,2,rep,name=objects" json:"objects,omitempty"` + ServiceId *uint32 `protobuf:"varint,3,opt,name=service_id" json:"service_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSerializedSOCache_TypeCache) Reset() { *m = CMsgSerializedSOCache_TypeCache{} } +func (m *CMsgSerializedSOCache_TypeCache) String() string { return proto.CompactTextString(m) } +func (*CMsgSerializedSOCache_TypeCache) ProtoMessage() {} +func (*CMsgSerializedSOCache_TypeCache) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{265, 0} +} + +func (m *CMsgSerializedSOCache_TypeCache) GetType() uint32 { + if m != nil && m.Type != nil { + return *m.Type + } + return 0 +} + +func (m *CMsgSerializedSOCache_TypeCache) GetObjects() [][]byte { + if m != nil { + return m.Objects + } + return nil +} + +func (m *CMsgSerializedSOCache_TypeCache) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +type CMsgSerializedSOCache_Cache struct { + Type *uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Id *uint64 `protobuf:"varint,2,opt,name=id" json:"id,omitempty"` + Versions []*CMsgSerializedSOCache_Cache_Version `protobuf:"bytes,3,rep,name=versions" json:"versions,omitempty"` + TypeCaches []*CMsgSerializedSOCache_TypeCache `protobuf:"bytes,4,rep,name=type_caches" json:"type_caches,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSerializedSOCache_Cache) Reset() { *m = CMsgSerializedSOCache_Cache{} } +func (m *CMsgSerializedSOCache_Cache) String() string { return proto.CompactTextString(m) } +func (*CMsgSerializedSOCache_Cache) ProtoMessage() {} +func (*CMsgSerializedSOCache_Cache) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{265, 1} +} + +func (m *CMsgSerializedSOCache_Cache) GetType() uint32 { + if m != nil && m.Type != nil { + return *m.Type + } + return 0 +} + +func (m *CMsgSerializedSOCache_Cache) GetId() uint64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CMsgSerializedSOCache_Cache) GetVersions() []*CMsgSerializedSOCache_Cache_Version { + if m != nil { + return m.Versions + } + return nil +} + +func (m *CMsgSerializedSOCache_Cache) GetTypeCaches() []*CMsgSerializedSOCache_TypeCache { + if m != nil { + return m.TypeCaches + } + return nil +} + +type CMsgSerializedSOCache_Cache_Version struct { + Service *uint32 `protobuf:"varint,1,opt,name=service" json:"service,omitempty"` + Version *uint64 `protobuf:"varint,2,opt,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSerializedSOCache_Cache_Version) Reset() { *m = CMsgSerializedSOCache_Cache_Version{} } +func (m *CMsgSerializedSOCache_Cache_Version) String() string { return proto.CompactTextString(m) } +func (*CMsgSerializedSOCache_Cache_Version) ProtoMessage() {} +func (*CMsgSerializedSOCache_Cache_Version) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{265, 1, 0} +} + +func (m *CMsgSerializedSOCache_Cache_Version) GetService() uint32 { + if m != nil && m.Service != nil { + return *m.Service + } + return 0 +} + +func (m *CMsgSerializedSOCache_Cache_Version) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +type CMsgRequestWeekendTourneySchedule struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestWeekendTourneySchedule) Reset() { *m = CMsgRequestWeekendTourneySchedule{} } +func (m *CMsgRequestWeekendTourneySchedule) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestWeekendTourneySchedule) ProtoMessage() {} +func (*CMsgRequestWeekendTourneySchedule) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{266} +} + +type CMsgWeekendTourneySchedule struct { + Divisions []*CMsgWeekendTourneySchedule_Division `protobuf:"bytes,1,rep,name=divisions" json:"divisions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgWeekendTourneySchedule) Reset() { *m = CMsgWeekendTourneySchedule{} } +func (m *CMsgWeekendTourneySchedule) String() string { return proto.CompactTextString(m) } +func (*CMsgWeekendTourneySchedule) ProtoMessage() {} +func (*CMsgWeekendTourneySchedule) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{267} } + +func (m *CMsgWeekendTourneySchedule) GetDivisions() []*CMsgWeekendTourneySchedule_Division { + if m != nil { + return m.Divisions + } + return nil +} + +type CMsgWeekendTourneySchedule_Division struct { + DivisionCode *uint32 `protobuf:"varint,1,opt,name=division_code" json:"division_code,omitempty"` + TimeWindowOpen *uint32 `protobuf:"varint,2,opt,name=time_window_open" json:"time_window_open,omitempty"` + TimeWindowClose *uint32 `protobuf:"varint,3,opt,name=time_window_close" json:"time_window_close,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgWeekendTourneySchedule_Division) Reset() { *m = CMsgWeekendTourneySchedule_Division{} } +func (m *CMsgWeekendTourneySchedule_Division) String() string { return proto.CompactTextString(m) } +func (*CMsgWeekendTourneySchedule_Division) ProtoMessage() {} +func (*CMsgWeekendTourneySchedule_Division) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{267, 0} +} + +func (m *CMsgWeekendTourneySchedule_Division) GetDivisionCode() uint32 { + if m != nil && m.DivisionCode != nil { + return *m.DivisionCode + } + return 0 +} + +func (m *CMsgWeekendTourneySchedule_Division) GetTimeWindowOpen() uint32 { + if m != nil && m.TimeWindowOpen != nil { + return *m.TimeWindowOpen + } + return 0 +} + +func (m *CMsgWeekendTourneySchedule_Division) GetTimeWindowClose() uint32 { + if m != nil && m.TimeWindowClose != nil { + return *m.TimeWindowClose + } + return 0 +} + +type CMsgClientProvideSurveyResult struct { + Responses []*CMsgClientProvideSurveyResult_Response `protobuf:"bytes,1,rep,name=responses" json:"responses,omitempty"` + SurveyKey *uint64 `protobuf:"varint,2,opt,name=survey_key" json:"survey_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientProvideSurveyResult) Reset() { *m = CMsgClientProvideSurveyResult{} } +func (m *CMsgClientProvideSurveyResult) String() string { return proto.CompactTextString(m) } +func (*CMsgClientProvideSurveyResult) ProtoMessage() {} +func (*CMsgClientProvideSurveyResult) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{268} } + +func (m *CMsgClientProvideSurveyResult) GetResponses() []*CMsgClientProvideSurveyResult_Response { + if m != nil { + return m.Responses + } + return nil +} + +func (m *CMsgClientProvideSurveyResult) GetSurveyKey() uint64 { + if m != nil && m.SurveyKey != nil { + return *m.SurveyKey + } + return 0 +} + +type CMsgClientProvideSurveyResult_Response struct { + QuestionId *uint32 `protobuf:"varint,1,opt,name=question_id" json:"question_id,omitempty"` + SurveyValue *uint32 `protobuf:"varint,2,opt,name=survey_value" json:"survey_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientProvideSurveyResult_Response) Reset() { + *m = CMsgClientProvideSurveyResult_Response{} +} +func (m *CMsgClientProvideSurveyResult_Response) String() string { return proto.CompactTextString(m) } +func (*CMsgClientProvideSurveyResult_Response) ProtoMessage() {} +func (*CMsgClientProvideSurveyResult_Response) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{268, 0} +} + +func (m *CMsgClientProvideSurveyResult_Response) GetQuestionId() uint32 { + if m != nil && m.QuestionId != nil { + return *m.QuestionId + } + return 0 +} + +func (m *CMsgClientProvideSurveyResult_Response) GetSurveyValue() uint32 { + if m != nil && m.SurveyValue != nil { + return *m.SurveyValue + } + return 0 +} + +type CMsgDOTAEmoticonAccessSDO struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + UnlockedEmoticons []byte `protobuf:"bytes,2,opt,name=unlocked_emoticons" json:"unlocked_emoticons,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEmoticonAccessSDO) Reset() { *m = CMsgDOTAEmoticonAccessSDO{} } +func (m *CMsgDOTAEmoticonAccessSDO) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEmoticonAccessSDO) ProtoMessage() {} +func (*CMsgDOTAEmoticonAccessSDO) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{269} } + +func (m *CMsgDOTAEmoticonAccessSDO) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAEmoticonAccessSDO) GetUnlockedEmoticons() []byte { + if m != nil { + return m.UnlockedEmoticons + } + return nil +} + +type CMsgClientToGCEmoticonDataRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCEmoticonDataRequest) Reset() { *m = CMsgClientToGCEmoticonDataRequest{} } +func (m *CMsgClientToGCEmoticonDataRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCEmoticonDataRequest) ProtoMessage() {} +func (*CMsgClientToGCEmoticonDataRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{270} +} + +type CMsgGCToClientEmoticonData struct { + EmoticonAccess *CMsgDOTAEmoticonAccessSDO `protobuf:"bytes,1,opt,name=emoticon_access" json:"emoticon_access,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientEmoticonData) Reset() { *m = CMsgGCToClientEmoticonData{} } +func (m *CMsgGCToClientEmoticonData) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientEmoticonData) ProtoMessage() {} +func (*CMsgGCToClientEmoticonData) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{271} } + +func (m *CMsgGCToClientEmoticonData) GetEmoticonAccess() *CMsgDOTAEmoticonAccessSDO { + if m != nil { + return m.EmoticonAccess + } + return nil +} + +type CMsgClientToGCTrackDialogResult struct { + DialogId *uint32 `protobuf:"varint,1,opt,name=dialog_id" json:"dialog_id,omitempty"` + Value *uint32 `protobuf:"varint,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCTrackDialogResult) Reset() { *m = CMsgClientToGCTrackDialogResult{} } +func (m *CMsgClientToGCTrackDialogResult) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCTrackDialogResult) ProtoMessage() {} +func (*CMsgClientToGCTrackDialogResult) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{272} +} + +func (m *CMsgClientToGCTrackDialogResult) GetDialogId() uint32 { + if m != nil && m.DialogId != nil { + return *m.DialogId + } + return 0 +} + +func (m *CMsgClientToGCTrackDialogResult) GetValue() uint32 { + if m != nil && m.Value != nil { + return *m.Value + } + return 0 +} + +type CMsgGCToClientTournamentItemDrop struct { + ItemDef *uint32 `protobuf:"varint,1,opt,name=item_def" json:"item_def,omitempty"` + EventType *uint32 `protobuf:"varint,2,opt,name=event_type" json:"event_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientTournamentItemDrop) Reset() { *m = CMsgGCToClientTournamentItemDrop{} } +func (m *CMsgGCToClientTournamentItemDrop) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientTournamentItemDrop) ProtoMessage() {} +func (*CMsgGCToClientTournamentItemDrop) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{273} +} + +func (m *CMsgGCToClientTournamentItemDrop) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +func (m *CMsgGCToClientTournamentItemDrop) GetEventType() uint32 { + if m != nil && m.EventType != nil { + return *m.EventType + } + return 0 +} + +type CMsgClientToGCSetAdditionalEquips struct { + Equips []*CAdditionalEquipSlot `protobuf:"bytes,1,rep,name=equips" json:"equips,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSetAdditionalEquips) Reset() { *m = CMsgClientToGCSetAdditionalEquips{} } +func (m *CMsgClientToGCSetAdditionalEquips) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCSetAdditionalEquips) ProtoMessage() {} +func (*CMsgClientToGCSetAdditionalEquips) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{274} +} + +func (m *CMsgClientToGCSetAdditionalEquips) GetEquips() []*CAdditionalEquipSlot { + if m != nil { + return m.Equips + } + return nil +} + +type CMsgClientToGCSetAdditionalEquipsResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSetAdditionalEquipsResponse) Reset() { + *m = CMsgClientToGCSetAdditionalEquipsResponse{} +} +func (m *CMsgClientToGCSetAdditionalEquipsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCSetAdditionalEquipsResponse) ProtoMessage() {} +func (*CMsgClientToGCSetAdditionalEquipsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{275} +} + +type CMsgClientToGCGetAdditionalEquips struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetAdditionalEquips) Reset() { *m = CMsgClientToGCGetAdditionalEquips{} } +func (m *CMsgClientToGCGetAdditionalEquips) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetAdditionalEquips) ProtoMessage() {} +func (*CMsgClientToGCGetAdditionalEquips) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{276} +} + +type CMsgClientToGCGetAdditionalEquipsResponse struct { + Equips []*CAdditionalEquipSlot `protobuf:"bytes,1,rep,name=equips" json:"equips,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetAdditionalEquipsResponse) Reset() { + *m = CMsgClientToGCGetAdditionalEquipsResponse{} +} +func (m *CMsgClientToGCGetAdditionalEquipsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetAdditionalEquipsResponse) ProtoMessage() {} +func (*CMsgClientToGCGetAdditionalEquipsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{277} +} + +func (m *CMsgClientToGCGetAdditionalEquipsResponse) GetEquips() []*CAdditionalEquipSlot { + if m != nil { + return m.Equips + } + return nil +} + +type CMsgClientToGCGetAllHeroOrder struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetAllHeroOrder) Reset() { *m = CMsgClientToGCGetAllHeroOrder{} } +func (m *CMsgClientToGCGetAllHeroOrder) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetAllHeroOrder) ProtoMessage() {} +func (*CMsgClientToGCGetAllHeroOrder) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{278} } + +type CMsgClientToGCGetAllHeroOrderResponse struct { + HeroIds []uint32 `protobuf:"varint,1,rep,name=hero_ids" json:"hero_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetAllHeroOrderResponse) Reset() { *m = CMsgClientToGCGetAllHeroOrderResponse{} } +func (m *CMsgClientToGCGetAllHeroOrderResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetAllHeroOrderResponse) ProtoMessage() {} +func (*CMsgClientToGCGetAllHeroOrderResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{279} +} + +func (m *CMsgClientToGCGetAllHeroOrderResponse) GetHeroIds() []uint32 { + if m != nil { + return m.HeroIds + } + return nil +} + +type CMsgClientToGCGetAllHeroProgress struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetAllHeroProgress) Reset() { *m = CMsgClientToGCGetAllHeroProgress{} } +func (m *CMsgClientToGCGetAllHeroProgress) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetAllHeroProgress) ProtoMessage() {} +func (*CMsgClientToGCGetAllHeroProgress) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{280} +} + +func (m *CMsgClientToGCGetAllHeroProgress) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgClientToGCGetAllHeroProgressResponse struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + CurrHeroId *uint32 `protobuf:"varint,2,opt,name=curr_hero_id" json:"curr_hero_id,omitempty"` + LapsCompleted *uint32 `protobuf:"varint,3,opt,name=laps_completed" json:"laps_completed,omitempty"` + CurrHeroGames *uint32 `protobuf:"varint,4,opt,name=curr_hero_games" json:"curr_hero_games,omitempty"` + CurrLapTimeStarted *uint32 `protobuf:"varint,5,opt,name=curr_lap_time_started" json:"curr_lap_time_started,omitempty"` + CurrLapGames *uint32 `protobuf:"varint,6,opt,name=curr_lap_games" json:"curr_lap_games,omitempty"` + BestLapGames *uint32 `protobuf:"varint,7,opt,name=best_lap_games" json:"best_lap_games,omitempty"` + BestLapTime *uint32 `protobuf:"varint,8,opt,name=best_lap_time" json:"best_lap_time,omitempty"` + LapHeroesCompleted *uint32 `protobuf:"varint,9,opt,name=lap_heroes_completed" json:"lap_heroes_completed,omitempty"` + LapHeroesRemaining *uint32 `protobuf:"varint,10,opt,name=lap_heroes_remaining" json:"lap_heroes_remaining,omitempty"` + NextHeroId *uint32 `protobuf:"varint,11,opt,name=next_hero_id" json:"next_hero_id,omitempty"` + PrevHeroId *uint32 `protobuf:"varint,12,opt,name=prev_hero_id" json:"prev_hero_id,omitempty"` + PrevHeroGames *uint32 `protobuf:"varint,13,opt,name=prev_hero_games" json:"prev_hero_games,omitempty"` + PrevAvgTries *float32 `protobuf:"fixed32,14,opt,name=prev_avg_tries" json:"prev_avg_tries,omitempty"` + CurrAvgTries *float32 `protobuf:"fixed32,15,opt,name=curr_avg_tries" json:"curr_avg_tries,omitempty"` + NextAvgTries *float32 `protobuf:"fixed32,16,opt,name=next_avg_tries" json:"next_avg_tries,omitempty"` + FullLapAvgTries *float32 `protobuf:"fixed32,17,opt,name=full_lap_avg_tries" json:"full_lap_avg_tries,omitempty"` + CurrLapAvgTries *float32 `protobuf:"fixed32,18,opt,name=curr_lap_avg_tries" json:"curr_lap_avg_tries,omitempty"` + ProfileName *string `protobuf:"bytes,19,opt,name=profile_name" json:"profile_name,omitempty"` + StartHeroId *uint32 `protobuf:"varint,20,opt,name=start_hero_id" json:"start_hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) Reset() { + *m = CMsgClientToGCGetAllHeroProgressResponse{} +} +func (m *CMsgClientToGCGetAllHeroProgressResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetAllHeroProgressResponse) ProtoMessage() {} +func (*CMsgClientToGCGetAllHeroProgressResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{281} +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetCurrHeroId() uint32 { + if m != nil && m.CurrHeroId != nil { + return *m.CurrHeroId + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetLapsCompleted() uint32 { + if m != nil && m.LapsCompleted != nil { + return *m.LapsCompleted + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetCurrHeroGames() uint32 { + if m != nil && m.CurrHeroGames != nil { + return *m.CurrHeroGames + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetCurrLapTimeStarted() uint32 { + if m != nil && m.CurrLapTimeStarted != nil { + return *m.CurrLapTimeStarted + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetCurrLapGames() uint32 { + if m != nil && m.CurrLapGames != nil { + return *m.CurrLapGames + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetBestLapGames() uint32 { + if m != nil && m.BestLapGames != nil { + return *m.BestLapGames + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetBestLapTime() uint32 { + if m != nil && m.BestLapTime != nil { + return *m.BestLapTime + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetLapHeroesCompleted() uint32 { + if m != nil && m.LapHeroesCompleted != nil { + return *m.LapHeroesCompleted + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetLapHeroesRemaining() uint32 { + if m != nil && m.LapHeroesRemaining != nil { + return *m.LapHeroesRemaining + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetNextHeroId() uint32 { + if m != nil && m.NextHeroId != nil { + return *m.NextHeroId + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetPrevHeroId() uint32 { + if m != nil && m.PrevHeroId != nil { + return *m.PrevHeroId + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetPrevHeroGames() uint32 { + if m != nil && m.PrevHeroGames != nil { + return *m.PrevHeroGames + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetPrevAvgTries() float32 { + if m != nil && m.PrevAvgTries != nil { + return *m.PrevAvgTries + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetCurrAvgTries() float32 { + if m != nil && m.CurrAvgTries != nil { + return *m.CurrAvgTries + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetNextAvgTries() float32 { + if m != nil && m.NextAvgTries != nil { + return *m.NextAvgTries + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetFullLapAvgTries() float32 { + if m != nil && m.FullLapAvgTries != nil { + return *m.FullLapAvgTries + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetCurrLapAvgTries() float32 { + if m != nil && m.CurrLapAvgTries != nil { + return *m.CurrLapAvgTries + } + return 0 +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetProfileName() string { + if m != nil && m.ProfileName != nil { + return *m.ProfileName + } + return "" +} + +func (m *CMsgClientToGCGetAllHeroProgressResponse) GetStartHeroId() uint32 { + if m != nil && m.StartHeroId != nil { + return *m.StartHeroId + } + return 0 +} + +type CMsgClientToGCGetTrophyList struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetTrophyList) Reset() { *m = CMsgClientToGCGetTrophyList{} } +func (m *CMsgClientToGCGetTrophyList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetTrophyList) ProtoMessage() {} +func (*CMsgClientToGCGetTrophyList) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{282} } + +func (m *CMsgClientToGCGetTrophyList) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgClientToGCGetTrophyListResponse struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Trophies []*CMsgClientToGCGetTrophyListResponse_Trophy `protobuf:"bytes,2,rep,name=trophies" json:"trophies,omitempty"` + ProfileName *string `protobuf:"bytes,3,opt,name=profile_name" json:"profile_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetTrophyListResponse) Reset() { *m = CMsgClientToGCGetTrophyListResponse{} } +func (m *CMsgClientToGCGetTrophyListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetTrophyListResponse) ProtoMessage() {} +func (*CMsgClientToGCGetTrophyListResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{283} +} + +func (m *CMsgClientToGCGetTrophyListResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgClientToGCGetTrophyListResponse) GetTrophies() []*CMsgClientToGCGetTrophyListResponse_Trophy { + if m != nil { + return m.Trophies + } + return nil +} + +func (m *CMsgClientToGCGetTrophyListResponse) GetProfileName() string { + if m != nil && m.ProfileName != nil { + return *m.ProfileName + } + return "" +} + +type CMsgClientToGCGetTrophyListResponse_Trophy struct { + TrophyId *uint32 `protobuf:"varint,1,opt,name=trophy_id" json:"trophy_id,omitempty"` + TrophyScore *uint32 `protobuf:"varint,2,opt,name=trophy_score" json:"trophy_score,omitempty"` + LastUpdated *uint32 `protobuf:"varint,3,opt,name=last_updated" json:"last_updated,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetTrophyListResponse_Trophy) Reset() { + *m = CMsgClientToGCGetTrophyListResponse_Trophy{} +} +func (m *CMsgClientToGCGetTrophyListResponse_Trophy) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCGetTrophyListResponse_Trophy) ProtoMessage() {} +func (*CMsgClientToGCGetTrophyListResponse_Trophy) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{283, 0} +} + +func (m *CMsgClientToGCGetTrophyListResponse_Trophy) GetTrophyId() uint32 { + if m != nil && m.TrophyId != nil { + return *m.TrophyId + } + return 0 +} + +func (m *CMsgClientToGCGetTrophyListResponse_Trophy) GetTrophyScore() uint32 { + if m != nil && m.TrophyScore != nil { + return *m.TrophyScore + } + return 0 +} + +func (m *CMsgClientToGCGetTrophyListResponse_Trophy) GetLastUpdated() uint32 { + if m != nil && m.LastUpdated != nil { + return *m.LastUpdated + } + return 0 +} + +type CMsgGCToClientTrophyAwarded struct { + TrophyId *uint32 `protobuf:"varint,1,opt,name=trophy_id" json:"trophy_id,omitempty"` + TrophyScore *uint32 `protobuf:"varint,2,opt,name=trophy_score" json:"trophy_score,omitempty"` + TrophyOldScore *uint32 `protobuf:"varint,3,opt,name=trophy_old_score" json:"trophy_old_score,omitempty"` + LastUpdated *uint32 `protobuf:"varint,4,opt,name=last_updated" json:"last_updated,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientTrophyAwarded) Reset() { *m = CMsgGCToClientTrophyAwarded{} } +func (m *CMsgGCToClientTrophyAwarded) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientTrophyAwarded) ProtoMessage() {} +func (*CMsgGCToClientTrophyAwarded) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{284} } + +func (m *CMsgGCToClientTrophyAwarded) GetTrophyId() uint32 { + if m != nil && m.TrophyId != nil { + return *m.TrophyId + } + return 0 +} + +func (m *CMsgGCToClientTrophyAwarded) GetTrophyScore() uint32 { + if m != nil && m.TrophyScore != nil { + return *m.TrophyScore + } + return 0 +} + +func (m *CMsgGCToClientTrophyAwarded) GetTrophyOldScore() uint32 { + if m != nil && m.TrophyOldScore != nil { + return *m.TrophyOldScore + } + return 0 +} + +func (m *CMsgGCToClientTrophyAwarded) GetLastUpdated() uint32 { + if m != nil && m.LastUpdated != nil { + return *m.LastUpdated + } + return 0 +} + +type CMsgClientToGCGetProfileCard struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetProfileCard) Reset() { *m = CMsgClientToGCGetProfileCard{} } +func (m *CMsgClientToGCGetProfileCard) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetProfileCard) ProtoMessage() {} +func (*CMsgClientToGCGetProfileCard) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{285} } + +func (m *CMsgClientToGCGetProfileCard) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgClientToGCSetProfileCardSlots struct { + Slots []*CMsgClientToGCSetProfileCardSlots_CardSlot `protobuf:"bytes,1,rep,name=slots" json:"slots,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSetProfileCardSlots) Reset() { *m = CMsgClientToGCSetProfileCardSlots{} } +func (m *CMsgClientToGCSetProfileCardSlots) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCSetProfileCardSlots) ProtoMessage() {} +func (*CMsgClientToGCSetProfileCardSlots) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{286} +} + +func (m *CMsgClientToGCSetProfileCardSlots) GetSlots() []*CMsgClientToGCSetProfileCardSlots_CardSlot { + if m != nil { + return m.Slots + } + return nil +} + +type CMsgClientToGCSetProfileCardSlots_CardSlot struct { + SlotId *uint32 `protobuf:"varint,1,opt,name=slot_id" json:"slot_id,omitempty"` + SlotType *EProfileCardSlotType `protobuf:"varint,2,opt,name=slot_type,enum=EProfileCardSlotType,def=0" json:"slot_type,omitempty"` + SlotValue *uint64 `protobuf:"varint,3,opt,name=slot_value" json:"slot_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSetProfileCardSlots_CardSlot) Reset() { + *m = CMsgClientToGCSetProfileCardSlots_CardSlot{} +} +func (m *CMsgClientToGCSetProfileCardSlots_CardSlot) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCSetProfileCardSlots_CardSlot) ProtoMessage() {} +func (*CMsgClientToGCSetProfileCardSlots_CardSlot) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{286, 0} +} + +const Default_CMsgClientToGCSetProfileCardSlots_CardSlot_SlotType EProfileCardSlotType = EProfileCardSlotType_k_EProfileCardSlotType_Empty + +func (m *CMsgClientToGCSetProfileCardSlots_CardSlot) GetSlotId() uint32 { + if m != nil && m.SlotId != nil { + return *m.SlotId + } + return 0 +} + +func (m *CMsgClientToGCSetProfileCardSlots_CardSlot) GetSlotType() EProfileCardSlotType { + if m != nil && m.SlotType != nil { + return *m.SlotType + } + return Default_CMsgClientToGCSetProfileCardSlots_CardSlot_SlotType +} + +func (m *CMsgClientToGCSetProfileCardSlots_CardSlot) GetSlotValue() uint64 { + if m != nil && m.SlotValue != nil { + return *m.SlotValue + } + return 0 +} + +type CMsgClientToGCGetProfileCardStats struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetProfileCardStats) Reset() { *m = CMsgClientToGCGetProfileCardStats{} } +func (m *CMsgClientToGCGetProfileCardStats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetProfileCardStats) ProtoMessage() {} +func (*CMsgClientToGCGetProfileCardStats) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{287} +} + +type CMsgClientToGCCreateHeroStatue struct { + SourceItem *uint64 `protobuf:"varint,1,opt,name=source_item" json:"source_item,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + SequenceName *string `protobuf:"bytes,4,opt,name=sequence_name" json:"sequence_name,omitempty"` + Cycle *float32 `protobuf:"fixed32,5,opt,name=cycle" json:"cycle,omitempty"` + Wearables []uint32 `protobuf:"varint,6,rep,name=wearables" json:"wearables,omitempty"` + Inscription *string `protobuf:"bytes,7,opt,name=inscription" json:"inscription,omitempty"` + Styles []uint32 `protobuf:"varint,8,rep,name=styles" json:"styles,omitempty"` + ReforgerItem *uint64 `protobuf:"varint,9,opt,name=reforger_item" json:"reforger_item,omitempty"` + TournamentDrop *bool `protobuf:"varint,10,opt,name=tournament_drop" json:"tournament_drop,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCCreateHeroStatue) Reset() { *m = CMsgClientToGCCreateHeroStatue{} } +func (m *CMsgClientToGCCreateHeroStatue) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCCreateHeroStatue) ProtoMessage() {} +func (*CMsgClientToGCCreateHeroStatue) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{288} +} + +func (m *CMsgClientToGCCreateHeroStatue) GetSourceItem() uint64 { + if m != nil && m.SourceItem != nil { + return *m.SourceItem + } + return 0 +} + +func (m *CMsgClientToGCCreateHeroStatue) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgClientToGCCreateHeroStatue) GetSequenceName() string { + if m != nil && m.SequenceName != nil { + return *m.SequenceName + } + return "" +} + +func (m *CMsgClientToGCCreateHeroStatue) GetCycle() float32 { + if m != nil && m.Cycle != nil { + return *m.Cycle + } + return 0 +} + +func (m *CMsgClientToGCCreateHeroStatue) GetWearables() []uint32 { + if m != nil { + return m.Wearables + } + return nil +} + +func (m *CMsgClientToGCCreateHeroStatue) GetInscription() string { + if m != nil && m.Inscription != nil { + return *m.Inscription + } + return "" +} + +func (m *CMsgClientToGCCreateHeroStatue) GetStyles() []uint32 { + if m != nil { + return m.Styles + } + return nil +} + +func (m *CMsgClientToGCCreateHeroStatue) GetReforgerItem() uint64 { + if m != nil && m.ReforgerItem != nil { + return *m.ReforgerItem + } + return 0 +} + +func (m *CMsgClientToGCCreateHeroStatue) GetTournamentDrop() bool { + if m != nil && m.TournamentDrop != nil { + return *m.TournamentDrop + } + return false +} + +type CMsgClientToGCCreateTeamShowcase struct { + SourceItem *uint64 `protobuf:"varint,1,opt,name=source_item" json:"source_item,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + SequenceName *string `protobuf:"bytes,4,opt,name=sequence_name" json:"sequence_name,omitempty"` + Cycle *float32 `protobuf:"fixed32,5,opt,name=cycle" json:"cycle,omitempty"` + Wearables []uint32 `protobuf:"varint,6,rep,name=wearables" json:"wearables,omitempty"` + Inscription *string `protobuf:"bytes,7,opt,name=inscription" json:"inscription,omitempty"` + Styles []uint32 `protobuf:"varint,8,rep,name=styles" json:"styles,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCCreateTeamShowcase) Reset() { *m = CMsgClientToGCCreateTeamShowcase{} } +func (m *CMsgClientToGCCreateTeamShowcase) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCCreateTeamShowcase) ProtoMessage() {} +func (*CMsgClientToGCCreateTeamShowcase) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{289} +} + +func (m *CMsgClientToGCCreateTeamShowcase) GetSourceItem() uint64 { + if m != nil && m.SourceItem != nil { + return *m.SourceItem + } + return 0 +} + +func (m *CMsgClientToGCCreateTeamShowcase) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgClientToGCCreateTeamShowcase) GetSequenceName() string { + if m != nil && m.SequenceName != nil { + return *m.SequenceName + } + return "" +} + +func (m *CMsgClientToGCCreateTeamShowcase) GetCycle() float32 { + if m != nil && m.Cycle != nil { + return *m.Cycle + } + return 0 +} + +func (m *CMsgClientToGCCreateTeamShowcase) GetWearables() []uint32 { + if m != nil { + return m.Wearables + } + return nil +} + +func (m *CMsgClientToGCCreateTeamShowcase) GetInscription() string { + if m != nil && m.Inscription != nil { + return *m.Inscription + } + return "" +} + +func (m *CMsgClientToGCCreateTeamShowcase) GetStyles() []uint32 { + if m != nil { + return m.Styles + } + return nil +} + +type CMsgGCToClientHeroStatueCreateResult struct { + ResultingItem *uint64 `protobuf:"varint,1,opt,name=resulting_item" json:"resulting_item,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientHeroStatueCreateResult) Reset() { *m = CMsgGCToClientHeroStatueCreateResult{} } +func (m *CMsgGCToClientHeroStatueCreateResult) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientHeroStatueCreateResult) ProtoMessage() {} +func (*CMsgGCToClientHeroStatueCreateResult) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{290} +} + +func (m *CMsgGCToClientHeroStatueCreateResult) GetResultingItem() uint64 { + if m != nil && m.ResultingItem != nil { + return *m.ResultingItem + } + return 0 +} + +type CMsgGCToClientTeamShowcaseCreateResult struct { + ResultingItem *uint64 `protobuf:"varint,1,opt,name=resulting_item" json:"resulting_item,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientTeamShowcaseCreateResult) Reset() { + *m = CMsgGCToClientTeamShowcaseCreateResult{} +} +func (m *CMsgGCToClientTeamShowcaseCreateResult) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientTeamShowcaseCreateResult) ProtoMessage() {} +func (*CMsgGCToClientTeamShowcaseCreateResult) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{291} +} + +func (m *CMsgGCToClientTeamShowcaseCreateResult) GetResultingItem() uint64 { + if m != nil && m.ResultingItem != nil { + return *m.ResultingItem + } + return 0 +} + +type CMsgClientToGCRecordCompendiumStats struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + ViewDurationS *uint32 `protobuf:"varint,2,opt,name=view_duration_s" json:"view_duration_s,omitempty"` + VideosViewed *uint32 `protobuf:"varint,3,opt,name=videos_viewed" json:"videos_viewed,omitempty"` + PageTurns *uint32 `protobuf:"varint,4,opt,name=page_turns" json:"page_turns,omitempty"` + LinksFollowed *uint32 `protobuf:"varint,5,opt,name=links_followed" json:"links_followed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCRecordCompendiumStats) Reset() { *m = CMsgClientToGCRecordCompendiumStats{} } +func (m *CMsgClientToGCRecordCompendiumStats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCRecordCompendiumStats) ProtoMessage() {} +func (*CMsgClientToGCRecordCompendiumStats) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{292} +} + +func (m *CMsgClientToGCRecordCompendiumStats) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgClientToGCRecordCompendiumStats) GetViewDurationS() uint32 { + if m != nil && m.ViewDurationS != nil { + return *m.ViewDurationS + } + return 0 +} + +func (m *CMsgClientToGCRecordCompendiumStats) GetVideosViewed() uint32 { + if m != nil && m.VideosViewed != nil { + return *m.VideosViewed + } + return 0 +} + +func (m *CMsgClientToGCRecordCompendiumStats) GetPageTurns() uint32 { + if m != nil && m.PageTurns != nil { + return *m.PageTurns + } + return 0 +} + +func (m *CMsgClientToGCRecordCompendiumStats) GetLinksFollowed() uint32 { + if m != nil && m.LinksFollowed != nil { + return *m.LinksFollowed + } + return 0 +} + +type CMsgGCToClientEventStatusChanged struct { + ActiveEvents []EEvent `protobuf:"varint,1,rep,name=active_events,enum=EEvent" json:"active_events,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientEventStatusChanged) Reset() { *m = CMsgGCToClientEventStatusChanged{} } +func (m *CMsgGCToClientEventStatusChanged) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientEventStatusChanged) ProtoMessage() {} +func (*CMsgGCToClientEventStatusChanged) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{293} +} + +func (m *CMsgGCToClientEventStatusChanged) GetActiveEvents() []EEvent { + if m != nil { + return m.ActiveEvents + } + return nil +} + +type CMsgClientToGCPlayerStatsRequest struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCPlayerStatsRequest) Reset() { *m = CMsgClientToGCPlayerStatsRequest{} } +func (m *CMsgClientToGCPlayerStatsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCPlayerStatsRequest) ProtoMessage() {} +func (*CMsgClientToGCPlayerStatsRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{294} +} + +func (m *CMsgClientToGCPlayerStatsRequest) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgGCToClientPlayerStatsResponse struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + PlayerStats []float32 `protobuf:"fixed32,2,rep,name=player_stats" json:"player_stats,omitempty"` + MatchCount *uint32 `protobuf:"varint,3,opt,name=match_count" json:"match_count,omitempty"` + MeanGpm *float32 `protobuf:"fixed32,4,opt,name=mean_gpm" json:"mean_gpm,omitempty"` + MeanXppm *float32 `protobuf:"fixed32,5,opt,name=mean_xppm" json:"mean_xppm,omitempty"` + MeanLasthits *float32 `protobuf:"fixed32,6,opt,name=mean_lasthits" json:"mean_lasthits,omitempty"` + Rampages *uint32 `protobuf:"varint,7,opt,name=rampages" json:"rampages,omitempty"` + TripleKills *uint32 `protobuf:"varint,8,opt,name=triple_kills" json:"triple_kills,omitempty"` + FirstBloodClaimed *uint32 `protobuf:"varint,9,opt,name=first_blood_claimed" json:"first_blood_claimed,omitempty"` + FirstBloodGiven *uint32 `protobuf:"varint,10,opt,name=first_blood_given" json:"first_blood_given,omitempty"` + CouriersKilled *uint32 `protobuf:"varint,11,opt,name=couriers_killed" json:"couriers_killed,omitempty"` + AegisesSnatched *uint32 `protobuf:"varint,12,opt,name=aegises_snatched" json:"aegises_snatched,omitempty"` + CheesesEaten *uint32 `protobuf:"varint,13,opt,name=cheeses_eaten" json:"cheeses_eaten,omitempty"` + CreepsStacked *uint32 `protobuf:"varint,14,opt,name=creeps_stacked" json:"creeps_stacked,omitempty"` + FightScore *float32 `protobuf:"fixed32,15,opt,name=fight_score" json:"fight_score,omitempty"` + FarmScore *float32 `protobuf:"fixed32,16,opt,name=farm_score" json:"farm_score,omitempty"` + SupportScore *float32 `protobuf:"fixed32,17,opt,name=support_score" json:"support_score,omitempty"` + PushScore *float32 `protobuf:"fixed32,18,opt,name=push_score" json:"push_score,omitempty"` + VersatilityScore *float32 `protobuf:"fixed32,19,opt,name=versatility_score" json:"versatility_score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientPlayerStatsResponse) Reset() { *m = CMsgGCToClientPlayerStatsResponse{} } +func (m *CMsgGCToClientPlayerStatsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientPlayerStatsResponse) ProtoMessage() {} +func (*CMsgGCToClientPlayerStatsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{295} +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetPlayerStats() []float32 { + if m != nil { + return m.PlayerStats + } + return nil +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetMatchCount() uint32 { + if m != nil && m.MatchCount != nil { + return *m.MatchCount + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetMeanGpm() float32 { + if m != nil && m.MeanGpm != nil { + return *m.MeanGpm + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetMeanXppm() float32 { + if m != nil && m.MeanXppm != nil { + return *m.MeanXppm + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetMeanLasthits() float32 { + if m != nil && m.MeanLasthits != nil { + return *m.MeanLasthits + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetRampages() uint32 { + if m != nil && m.Rampages != nil { + return *m.Rampages + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetTripleKills() uint32 { + if m != nil && m.TripleKills != nil { + return *m.TripleKills + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetFirstBloodClaimed() uint32 { + if m != nil && m.FirstBloodClaimed != nil { + return *m.FirstBloodClaimed + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetFirstBloodGiven() uint32 { + if m != nil && m.FirstBloodGiven != nil { + return *m.FirstBloodGiven + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetCouriersKilled() uint32 { + if m != nil && m.CouriersKilled != nil { + return *m.CouriersKilled + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetAegisesSnatched() uint32 { + if m != nil && m.AegisesSnatched != nil { + return *m.AegisesSnatched + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetCheesesEaten() uint32 { + if m != nil && m.CheesesEaten != nil { + return *m.CheesesEaten + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetCreepsStacked() uint32 { + if m != nil && m.CreepsStacked != nil { + return *m.CreepsStacked + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetFightScore() float32 { + if m != nil && m.FightScore != nil { + return *m.FightScore + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetFarmScore() float32 { + if m != nil && m.FarmScore != nil { + return *m.FarmScore + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetSupportScore() float32 { + if m != nil && m.SupportScore != nil { + return *m.SupportScore + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetPushScore() float32 { + if m != nil && m.PushScore != nil { + return *m.PushScore + } + return 0 +} + +func (m *CMsgGCToClientPlayerStatsResponse) GetVersatilityScore() float32 { + if m != nil && m.VersatilityScore != nil { + return *m.VersatilityScore + } + return 0 +} + +type CMsgClientToGCCustomGamePlayerCountRequest struct { + CustomGameId *uint64 `protobuf:"varint,1,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCCustomGamePlayerCountRequest) Reset() { + *m = CMsgClientToGCCustomGamePlayerCountRequest{} +} +func (m *CMsgClientToGCCustomGamePlayerCountRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCCustomGamePlayerCountRequest) ProtoMessage() {} +func (*CMsgClientToGCCustomGamePlayerCountRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{296} +} + +func (m *CMsgClientToGCCustomGamePlayerCountRequest) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +type CMsgGCToClientCustomGamePlayerCountResponse struct { + CustomGameId *uint64 `protobuf:"varint,1,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + PlayerCount *uint64 `protobuf:"varint,2,opt,name=player_count" json:"player_count,omitempty"` + SpectatorCount *uint64 `protobuf:"varint,3,opt,name=spectator_count" json:"spectator_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientCustomGamePlayerCountResponse) Reset() { + *m = CMsgGCToClientCustomGamePlayerCountResponse{} +} +func (m *CMsgGCToClientCustomGamePlayerCountResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientCustomGamePlayerCountResponse) ProtoMessage() {} +func (*CMsgGCToClientCustomGamePlayerCountResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{297} +} + +func (m *CMsgGCToClientCustomGamePlayerCountResponse) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgGCToClientCustomGamePlayerCountResponse) GetPlayerCount() uint64 { + if m != nil && m.PlayerCount != nil { + return *m.PlayerCount + } + return 0 +} + +func (m *CMsgGCToClientCustomGamePlayerCountResponse) GetSpectatorCount() uint64 { + if m != nil && m.SpectatorCount != nil { + return *m.SpectatorCount + } + return 0 +} + +type CMsgClientToGCCustomGamesFriendsPlayedRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCCustomGamesFriendsPlayedRequest) Reset() { + *m = CMsgClientToGCCustomGamesFriendsPlayedRequest{} +} +func (m *CMsgClientToGCCustomGamesFriendsPlayedRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCCustomGamesFriendsPlayedRequest) ProtoMessage() {} +func (*CMsgClientToGCCustomGamesFriendsPlayedRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{298} +} + +type CMsgGCToClientCustomGamesFriendsPlayedResponse struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Games []*CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame `protobuf:"bytes,2,rep,name=games" json:"games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse) Reset() { + *m = CMsgGCToClientCustomGamesFriendsPlayedResponse{} +} +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientCustomGamesFriendsPlayedResponse) ProtoMessage() {} +func (*CMsgGCToClientCustomGamesFriendsPlayedResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{299} +} + +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse) GetGames() []*CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame { + if m != nil { + return m.Games + } + return nil +} + +type CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame struct { + CustomGameId *uint64 `protobuf:"varint,1,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + AccountIds []uint32 `protobuf:"varint,2,rep,name=account_ids" json:"account_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame) Reset() { + *m = CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame{} +} +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame) ProtoMessage() {} +func (*CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{299, 0} +} + +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame) GetAccountIds() []uint32 { + if m != nil { + return m.AccountIds + } + return nil +} + +type CMsgClientToGCSocialFeedPostCommentRequest struct { + EventId *uint64 `protobuf:"varint,1,opt,name=event_id" json:"event_id,omitempty"` + Comment *string `protobuf:"bytes,2,opt,name=comment" json:"comment,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSocialFeedPostCommentRequest) Reset() { + *m = CMsgClientToGCSocialFeedPostCommentRequest{} +} +func (m *CMsgClientToGCSocialFeedPostCommentRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCSocialFeedPostCommentRequest) ProtoMessage() {} +func (*CMsgClientToGCSocialFeedPostCommentRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{300} +} + +func (m *CMsgClientToGCSocialFeedPostCommentRequest) GetEventId() uint64 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CMsgClientToGCSocialFeedPostCommentRequest) GetComment() string { + if m != nil && m.Comment != nil { + return *m.Comment + } + return "" +} + +type CMsgGCToClientSocialFeedPostCommentResponse struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientSocialFeedPostCommentResponse) Reset() { + *m = CMsgGCToClientSocialFeedPostCommentResponse{} +} +func (m *CMsgGCToClientSocialFeedPostCommentResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientSocialFeedPostCommentResponse) ProtoMessage() {} +func (*CMsgGCToClientSocialFeedPostCommentResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{301} +} + +func (m *CMsgGCToClientSocialFeedPostCommentResponse) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +type CMsgClientToGCSocialFeedPostMessageRequest struct { + Message *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"` + MatchId *uint64 `protobuf:"varint,2,opt,name=match_id" json:"match_id,omitempty"` + MatchTimestamp *uint32 `protobuf:"varint,3,opt,name=match_timestamp" json:"match_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSocialFeedPostMessageRequest) Reset() { + *m = CMsgClientToGCSocialFeedPostMessageRequest{} +} +func (m *CMsgClientToGCSocialFeedPostMessageRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCSocialFeedPostMessageRequest) ProtoMessage() {} +func (*CMsgClientToGCSocialFeedPostMessageRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{302} +} + +func (m *CMsgClientToGCSocialFeedPostMessageRequest) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgClientToGCSocialFeedPostMessageRequest) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgClientToGCSocialFeedPostMessageRequest) GetMatchTimestamp() uint32 { + if m != nil && m.MatchTimestamp != nil { + return *m.MatchTimestamp + } + return 0 +} + +type CMsgGCToClientSocialFeedPostMessageResponse struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientSocialFeedPostMessageResponse) Reset() { + *m = CMsgGCToClientSocialFeedPostMessageResponse{} +} +func (m *CMsgGCToClientSocialFeedPostMessageResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientSocialFeedPostMessageResponse) ProtoMessage() {} +func (*CMsgGCToClientSocialFeedPostMessageResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{303} +} + +func (m *CMsgGCToClientSocialFeedPostMessageResponse) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +type CMsgClientToGCFriendsPlayedCustomGameRequest struct { + CustomGameId *uint64 `protobuf:"varint,1,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCFriendsPlayedCustomGameRequest) Reset() { + *m = CMsgClientToGCFriendsPlayedCustomGameRequest{} +} +func (m *CMsgClientToGCFriendsPlayedCustomGameRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCFriendsPlayedCustomGameRequest) ProtoMessage() {} +func (*CMsgClientToGCFriendsPlayedCustomGameRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{304} +} + +func (m *CMsgClientToGCFriendsPlayedCustomGameRequest) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +type CMsgGCToClientFriendsPlayedCustomGameResponse struct { + CustomGameId *uint64 `protobuf:"varint,1,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + AccountIds []uint32 `protobuf:"varint,2,rep,name=account_ids" json:"account_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientFriendsPlayedCustomGameResponse) Reset() { + *m = CMsgGCToClientFriendsPlayedCustomGameResponse{} +} +func (m *CMsgGCToClientFriendsPlayedCustomGameResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientFriendsPlayedCustomGameResponse) ProtoMessage() {} +func (*CMsgGCToClientFriendsPlayedCustomGameResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{305} +} + +func (m *CMsgGCToClientFriendsPlayedCustomGameResponse) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgGCToClientFriendsPlayedCustomGameResponse) GetAccountIds() []uint32 { + if m != nil { + return m.AccountIds + } + return nil +} + +type CMsgClientToGCFeaturedHeroesRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCFeaturedHeroesRequest) Reset() { *m = CMsgClientToGCFeaturedHeroesRequest{} } +func (m *CMsgClientToGCFeaturedHeroesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCFeaturedHeroesRequest) ProtoMessage() {} +func (*CMsgClientToGCFeaturedHeroesRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{306} +} + +type CMsgGCToClientFeaturedHeroesResponse struct { + Categories []*CMsgGCToClientFeaturedHeroesResponse_Category `protobuf:"bytes,1,rep,name=categories" json:"categories,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientFeaturedHeroesResponse) Reset() { *m = CMsgGCToClientFeaturedHeroesResponse{} } +func (m *CMsgGCToClientFeaturedHeroesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientFeaturedHeroesResponse) ProtoMessage() {} +func (*CMsgGCToClientFeaturedHeroesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{307} +} + +func (m *CMsgGCToClientFeaturedHeroesResponse) GetCategories() []*CMsgGCToClientFeaturedHeroesResponse_Category { + if m != nil { + return m.Categories + } + return nil +} + +type CMsgGCToClientFeaturedHeroesResponse_DataField struct { + DataType *EFeaturedHeroDataType `protobuf:"varint,1,opt,name=data_type,enum=EFeaturedHeroDataType,def=0" json:"data_type,omitempty"` + Uint32Value *uint32 `protobuf:"varint,2,opt,name=uint32_value" json:"uint32_value,omitempty"` + Uint64Value *uint64 `protobuf:"varint,3,opt,name=uint64_value" json:"uint64_value,omitempty"` + StringValue *string `protobuf:"bytes,4,opt,name=string_value" json:"string_value,omitempty"` + FloatValue *float32 `protobuf:"fixed32,5,opt,name=float_value" json:"float_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_DataField) Reset() { + *m = CMsgGCToClientFeaturedHeroesResponse_DataField{} +} +func (m *CMsgGCToClientFeaturedHeroesResponse_DataField) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientFeaturedHeroesResponse_DataField) ProtoMessage() {} +func (*CMsgGCToClientFeaturedHeroesResponse_DataField) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{307, 0} +} + +const Default_CMsgGCToClientFeaturedHeroesResponse_DataField_DataType EFeaturedHeroDataType = EFeaturedHeroDataType_k_EFeaturedHeroDataType_HeroID + +func (m *CMsgGCToClientFeaturedHeroesResponse_DataField) GetDataType() EFeaturedHeroDataType { + if m != nil && m.DataType != nil { + return *m.DataType + } + return Default_CMsgGCToClientFeaturedHeroesResponse_DataField_DataType +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_DataField) GetUint32Value() uint32 { + if m != nil && m.Uint32Value != nil { + return *m.Uint32Value + } + return 0 +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_DataField) GetUint64Value() uint64 { + if m != nil && m.Uint64Value != nil { + return *m.Uint64Value + } + return 0 +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_DataField) GetStringValue() string { + if m != nil && m.StringValue != nil { + return *m.StringValue + } + return "" +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_DataField) GetFloatValue() float32 { + if m != nil && m.FloatValue != nil { + return *m.FloatValue + } + return 0 +} + +type CMsgGCToClientFeaturedHeroesResponse_FeaturedHero struct { + DataFields []*CMsgGCToClientFeaturedHeroesResponse_DataField `protobuf:"bytes,1,rep,name=data_fields" json:"data_fields,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_FeaturedHero) Reset() { + *m = CMsgGCToClientFeaturedHeroesResponse_FeaturedHero{} +} +func (m *CMsgGCToClientFeaturedHeroesResponse_FeaturedHero) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientFeaturedHeroesResponse_FeaturedHero) ProtoMessage() {} +func (*CMsgGCToClientFeaturedHeroesResponse_FeaturedHero) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{307, 1} +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_FeaturedHero) GetDataFields() []*CMsgGCToClientFeaturedHeroesResponse_DataField { + if m != nil { + return m.DataFields + } + return nil +} + +type CMsgGCToClientFeaturedHeroesResponse_Category struct { + CategoryWeight *int32 `protobuf:"varint,1,opt,name=category_weight" json:"category_weight,omitempty"` + TextFields []EFeaturedHeroTextField `protobuf:"varint,2,rep,name=text_fields,enum=EFeaturedHeroTextField" json:"text_fields,omitempty"` + FeaturedHeroes []*CMsgGCToClientFeaturedHeroesResponse_FeaturedHero `protobuf:"bytes,3,rep,name=featured_heroes" json:"featured_heroes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_Category) Reset() { + *m = CMsgGCToClientFeaturedHeroesResponse_Category{} +} +func (m *CMsgGCToClientFeaturedHeroesResponse_Category) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientFeaturedHeroesResponse_Category) ProtoMessage() {} +func (*CMsgGCToClientFeaturedHeroesResponse_Category) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{307, 2} +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_Category) GetCategoryWeight() int32 { + if m != nil && m.CategoryWeight != nil { + return *m.CategoryWeight + } + return 0 +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_Category) GetTextFields() []EFeaturedHeroTextField { + if m != nil { + return m.TextFields + } + return nil +} + +func (m *CMsgGCToClientFeaturedHeroesResponse_Category) GetFeaturedHeroes() []*CMsgGCToClientFeaturedHeroesResponse_FeaturedHero { + if m != nil { + return m.FeaturedHeroes + } + return nil +} + +type CMsgClientToGCSocialMatchPostCommentRequest struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + Comment *string `protobuf:"bytes,2,opt,name=comment" json:"comment,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSocialMatchPostCommentRequest) Reset() { + *m = CMsgClientToGCSocialMatchPostCommentRequest{} +} +func (m *CMsgClientToGCSocialMatchPostCommentRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCSocialMatchPostCommentRequest) ProtoMessage() {} +func (*CMsgClientToGCSocialMatchPostCommentRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{308} +} + +func (m *CMsgClientToGCSocialMatchPostCommentRequest) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgClientToGCSocialMatchPostCommentRequest) GetComment() string { + if m != nil && m.Comment != nil { + return *m.Comment + } + return "" +} + +type CMsgGCToClientSocialMatchPostCommentResponse struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientSocialMatchPostCommentResponse) Reset() { + *m = CMsgGCToClientSocialMatchPostCommentResponse{} +} +func (m *CMsgGCToClientSocialMatchPostCommentResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientSocialMatchPostCommentResponse) ProtoMessage() {} +func (*CMsgGCToClientSocialMatchPostCommentResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{309} +} + +func (m *CMsgGCToClientSocialMatchPostCommentResponse) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +type CMsgClientToGCSocialMatchDetailsRequest struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + PaginationTimestamp *uint32 `protobuf:"varint,2,opt,name=pagination_timestamp" json:"pagination_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSocialMatchDetailsRequest) Reset() { + *m = CMsgClientToGCSocialMatchDetailsRequest{} +} +func (m *CMsgClientToGCSocialMatchDetailsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCSocialMatchDetailsRequest) ProtoMessage() {} +func (*CMsgClientToGCSocialMatchDetailsRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{310} +} + +func (m *CMsgClientToGCSocialMatchDetailsRequest) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgClientToGCSocialMatchDetailsRequest) GetPaginationTimestamp() uint32 { + if m != nil && m.PaginationTimestamp != nil { + return *m.PaginationTimestamp + } + return 0 +} + +type CMsgGCToClientSocialMatchDetailsResponse struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + Comments []*CMsgGCToClientSocialMatchDetailsResponse_Comment `protobuf:"bytes,2,rep,name=comments" json:"comments,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse) Reset() { + *m = CMsgGCToClientSocialMatchDetailsResponse{} +} +func (m *CMsgGCToClientSocialMatchDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientSocialMatchDetailsResponse) ProtoMessage() {} +func (*CMsgGCToClientSocialMatchDetailsResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{311} +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse) GetComments() []*CMsgGCToClientSocialMatchDetailsResponse_Comment { + if m != nil { + return m.Comments + } + return nil +} + +type CMsgGCToClientSocialMatchDetailsResponse_Comment struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + PersonaName *string `protobuf:"bytes,2,opt,name=persona_name" json:"persona_name,omitempty"` + Timestamp *uint32 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` + Comment *string `protobuf:"bytes,4,opt,name=comment" json:"comment,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse_Comment) Reset() { + *m = CMsgGCToClientSocialMatchDetailsResponse_Comment{} +} +func (m *CMsgGCToClientSocialMatchDetailsResponse_Comment) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientSocialMatchDetailsResponse_Comment) ProtoMessage() {} +func (*CMsgGCToClientSocialMatchDetailsResponse_Comment) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{311, 0} +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse_Comment) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse_Comment) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse_Comment) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgGCToClientSocialMatchDetailsResponse_Comment) GetComment() string { + if m != nil && m.Comment != nil { + return *m.Comment + } + return "" +} + +type CMsgDOTAPartyMemberSetCoach struct { + WantsCoach *bool `protobuf:"varint,1,opt,name=wants_coach" json:"wants_coach,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPartyMemberSetCoach) Reset() { *m = CMsgDOTAPartyMemberSetCoach{} } +func (m *CMsgDOTAPartyMemberSetCoach) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPartyMemberSetCoach) ProtoMessage() {} +func (*CMsgDOTAPartyMemberSetCoach) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{312} } + +func (m *CMsgDOTAPartyMemberSetCoach) GetWantsCoach() bool { + if m != nil && m.WantsCoach != nil { + return *m.WantsCoach + } + return false +} + +type CMsgDOTASetGroupLeader struct { + NewLeaderSteamid *uint64 `protobuf:"fixed64,1,opt,name=new_leader_steamid" json:"new_leader_steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASetGroupLeader) Reset() { *m = CMsgDOTASetGroupLeader{} } +func (m *CMsgDOTASetGroupLeader) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASetGroupLeader) ProtoMessage() {} +func (*CMsgDOTASetGroupLeader) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{313} } + +func (m *CMsgDOTASetGroupLeader) GetNewLeaderSteamid() uint64 { + if m != nil && m.NewLeaderSteamid != nil { + return *m.NewLeaderSteamid + } + return 0 +} + +type CMsgDOTACancelGroupInvites struct { + InvitedSteamids []uint64 `protobuf:"fixed64,1,rep,name=invited_steamids" json:"invited_steamids,omitempty"` + InvitedGroupids []uint64 `protobuf:"fixed64,2,rep,name=invited_groupids" json:"invited_groupids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACancelGroupInvites) Reset() { *m = CMsgDOTACancelGroupInvites{} } +func (m *CMsgDOTACancelGroupInvites) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACancelGroupInvites) ProtoMessage() {} +func (*CMsgDOTACancelGroupInvites) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{314} } + +func (m *CMsgDOTACancelGroupInvites) GetInvitedSteamids() []uint64 { + if m != nil { + return m.InvitedSteamids + } + return nil +} + +func (m *CMsgDOTACancelGroupInvites) GetInvitedGroupids() []uint64 { + if m != nil { + return m.InvitedGroupids + } + return nil +} + +type CMsgDOTASetGroupOpenStatus struct { + Open *bool `protobuf:"varint,1,opt,name=open" json:"open,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASetGroupOpenStatus) Reset() { *m = CMsgDOTASetGroupOpenStatus{} } +func (m *CMsgDOTASetGroupOpenStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASetGroupOpenStatus) ProtoMessage() {} +func (*CMsgDOTASetGroupOpenStatus) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{315} } + +func (m *CMsgDOTASetGroupOpenStatus) GetOpen() bool { + if m != nil && m.Open != nil { + return *m.Open + } + return false +} + +type CMsgDOTAGroupMergeInvite struct { + OtherGroupId *uint64 `protobuf:"fixed64,1,opt,name=other_group_id" json:"other_group_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGroupMergeInvite) Reset() { *m = CMsgDOTAGroupMergeInvite{} } +func (m *CMsgDOTAGroupMergeInvite) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGroupMergeInvite) ProtoMessage() {} +func (*CMsgDOTAGroupMergeInvite) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{316} } + +func (m *CMsgDOTAGroupMergeInvite) GetOtherGroupId() uint64 { + if m != nil && m.OtherGroupId != nil { + return *m.OtherGroupId + } + return 0 +} + +type CMsgDOTAGroupMergeResponse struct { + InitiatorGroupId *uint64 `protobuf:"fixed64,1,opt,name=initiator_group_id" json:"initiator_group_id,omitempty"` + Accept *bool `protobuf:"varint,2,opt,name=accept" json:"accept,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGroupMergeResponse) Reset() { *m = CMsgDOTAGroupMergeResponse{} } +func (m *CMsgDOTAGroupMergeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGroupMergeResponse) ProtoMessage() {} +func (*CMsgDOTAGroupMergeResponse) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{317} } + +func (m *CMsgDOTAGroupMergeResponse) GetInitiatorGroupId() uint64 { + if m != nil && m.InitiatorGroupId != nil { + return *m.InitiatorGroupId + } + return 0 +} + +func (m *CMsgDOTAGroupMergeResponse) GetAccept() bool { + if m != nil && m.Accept != nil { + return *m.Accept + } + return false +} + +type CMsgDOTAGroupMergeReply struct { + Result *EDOTAGroupMergeResult `protobuf:"varint,1,opt,name=result,enum=EDOTAGroupMergeResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAGroupMergeReply) Reset() { *m = CMsgDOTAGroupMergeReply{} } +func (m *CMsgDOTAGroupMergeReply) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAGroupMergeReply) ProtoMessage() {} +func (*CMsgDOTAGroupMergeReply) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{318} } + +const Default_CMsgDOTAGroupMergeReply_Result EDOTAGroupMergeResult = EDOTAGroupMergeResult_k_EDOTAGroupMergeResult_OK + +func (m *CMsgDOTAGroupMergeReply) GetResult() EDOTAGroupMergeResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAGroupMergeReply_Result +} + +type CMsgDOTAPartyRichPresence struct { + PartyId *uint64 `protobuf:"fixed64,1,opt,name=party_id" json:"party_id,omitempty"` + PartyState *CSODOTAParty_State `protobuf:"varint,2,opt,name=party_state,enum=CSODOTAParty_State,def=0" json:"party_state,omitempty"` + Open *bool `protobuf:"varint,3,opt,name=open" json:"open,omitempty"` + LowPriority *bool `protobuf:"varint,5,opt,name=low_priority" json:"low_priority,omitempty"` + Members []*CMsgDOTAPartyRichPresence_Member `protobuf:"bytes,4,rep,name=members" json:"members,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPartyRichPresence) Reset() { *m = CMsgDOTAPartyRichPresence{} } +func (m *CMsgDOTAPartyRichPresence) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPartyRichPresence) ProtoMessage() {} +func (*CMsgDOTAPartyRichPresence) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{319} } + +const Default_CMsgDOTAPartyRichPresence_PartyState CSODOTAParty_State = CSODOTAParty_UI + +func (m *CMsgDOTAPartyRichPresence) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CMsgDOTAPartyRichPresence) GetPartyState() CSODOTAParty_State { + if m != nil && m.PartyState != nil { + return *m.PartyState + } + return Default_CMsgDOTAPartyRichPresence_PartyState +} + +func (m *CMsgDOTAPartyRichPresence) GetOpen() bool { + if m != nil && m.Open != nil { + return *m.Open + } + return false +} + +func (m *CMsgDOTAPartyRichPresence) GetLowPriority() bool { + if m != nil && m.LowPriority != nil { + return *m.LowPriority + } + return false +} + +func (m *CMsgDOTAPartyRichPresence) GetMembers() []*CMsgDOTAPartyRichPresence_Member { + if m != nil { + return m.Members + } + return nil +} + +type CMsgDOTAPartyRichPresence_Member struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + Coach *bool `protobuf:"varint,2,opt,name=coach" json:"coach,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPartyRichPresence_Member) Reset() { *m = CMsgDOTAPartyRichPresence_Member{} } +func (m *CMsgDOTAPartyRichPresence_Member) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPartyRichPresence_Member) ProtoMessage() {} +func (*CMsgDOTAPartyRichPresence_Member) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{319, 0} +} + +func (m *CMsgDOTAPartyRichPresence_Member) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTAPartyRichPresence_Member) GetCoach() bool { + if m != nil && m.Coach != nil { + return *m.Coach + } + return false +} + +type CMsgDOTALobbyRichPresence struct { + LobbyId *uint64 `protobuf:"fixed64,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + LobbyState *CSODOTALobby_State `protobuf:"varint,2,opt,name=lobby_state,enum=CSODOTALobby_State,def=0" json:"lobby_state,omitempty"` + Password *bool `protobuf:"varint,3,opt,name=password" json:"password,omitempty"` + GameMode *DOTA_GameMode `protobuf:"varint,4,opt,name=game_mode,enum=DOTA_GameMode,def=0" json:"game_mode,omitempty"` + MemberCount *uint32 `protobuf:"varint,5,opt,name=member_count" json:"member_count,omitempty"` + MaxMemberCount *uint32 `protobuf:"varint,6,opt,name=max_member_count" json:"max_member_count,omitempty"` + CustomGameId *uint64 `protobuf:"fixed64,7,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + Name *string `protobuf:"bytes,8,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTALobbyRichPresence) Reset() { *m = CMsgDOTALobbyRichPresence{} } +func (m *CMsgDOTALobbyRichPresence) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTALobbyRichPresence) ProtoMessage() {} +func (*CMsgDOTALobbyRichPresence) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{320} } + +const Default_CMsgDOTALobbyRichPresence_LobbyState CSODOTALobby_State = CSODOTALobby_UI +const Default_CMsgDOTALobbyRichPresence_GameMode DOTA_GameMode = DOTA_GameMode_DOTA_GAMEMODE_NONE + +func (m *CMsgDOTALobbyRichPresence) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgDOTALobbyRichPresence) GetLobbyState() CSODOTALobby_State { + if m != nil && m.LobbyState != nil { + return *m.LobbyState + } + return Default_CMsgDOTALobbyRichPresence_LobbyState +} + +func (m *CMsgDOTALobbyRichPresence) GetPassword() bool { + if m != nil && m.Password != nil { + return *m.Password + } + return false +} + +func (m *CMsgDOTALobbyRichPresence) GetGameMode() DOTA_GameMode { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return Default_CMsgDOTALobbyRichPresence_GameMode +} + +func (m *CMsgDOTALobbyRichPresence) GetMemberCount() uint32 { + if m != nil && m.MemberCount != nil { + return *m.MemberCount + } + return 0 +} + +func (m *CMsgDOTALobbyRichPresence) GetMaxMemberCount() uint32 { + if m != nil && m.MaxMemberCount != nil { + return *m.MaxMemberCount + } + return 0 +} + +func (m *CMsgDOTALobbyRichPresence) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgDOTALobbyRichPresence) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type CMsgDOTACustomGameListenServerStartedLoading struct { + LobbyId *uint64 `protobuf:"fixed64,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + CustomGameId *uint64 `protobuf:"varint,2,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + LobbyMembers []uint32 `protobuf:"varint,3,rep,name=lobby_members" json:"lobby_members,omitempty"` + StartTime *uint32 `protobuf:"varint,4,opt,name=start_time" json:"start_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACustomGameListenServerStartedLoading) Reset() { + *m = CMsgDOTACustomGameListenServerStartedLoading{} +} +func (m *CMsgDOTACustomGameListenServerStartedLoading) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTACustomGameListenServerStartedLoading) ProtoMessage() {} +func (*CMsgDOTACustomGameListenServerStartedLoading) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{321} +} + +func (m *CMsgDOTACustomGameListenServerStartedLoading) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgDOTACustomGameListenServerStartedLoading) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CMsgDOTACustomGameListenServerStartedLoading) GetLobbyMembers() []uint32 { + if m != nil { + return m.LobbyMembers + } + return nil +} + +func (m *CMsgDOTACustomGameListenServerStartedLoading) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +type CMsgDOTACustomGameClientFinishedLoading struct { + LobbyId *uint64 `protobuf:"fixed64,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + LoadingDuration *uint32 `protobuf:"varint,2,opt,name=loading_duration" json:"loading_duration,omitempty"` + ResultCode *int32 `protobuf:"zigzag32,3,opt,name=result_code" json:"result_code,omitempty"` + ResultString *string `protobuf:"bytes,4,opt,name=result_string" json:"result_string,omitempty"` + SignonStates *uint32 `protobuf:"varint,5,opt,name=signon_states" json:"signon_states,omitempty"` + Comment *string `protobuf:"bytes,6,opt,name=comment" json:"comment,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACustomGameClientFinishedLoading) Reset() { + *m = CMsgDOTACustomGameClientFinishedLoading{} +} +func (m *CMsgDOTACustomGameClientFinishedLoading) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACustomGameClientFinishedLoading) ProtoMessage() {} +func (*CMsgDOTACustomGameClientFinishedLoading) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{322} +} + +func (m *CMsgDOTACustomGameClientFinishedLoading) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgDOTACustomGameClientFinishedLoading) GetLoadingDuration() uint32 { + if m != nil && m.LoadingDuration != nil { + return *m.LoadingDuration + } + return 0 +} + +func (m *CMsgDOTACustomGameClientFinishedLoading) GetResultCode() int32 { + if m != nil && m.ResultCode != nil { + return *m.ResultCode + } + return 0 +} + +func (m *CMsgDOTACustomGameClientFinishedLoading) GetResultString() string { + if m != nil && m.ResultString != nil { + return *m.ResultString + } + return "" +} + +func (m *CMsgDOTACustomGameClientFinishedLoading) GetSignonStates() uint32 { + if m != nil && m.SignonStates != nil { + return *m.SignonStates + } + return 0 +} + +func (m *CMsgDOTACustomGameClientFinishedLoading) GetComment() string { + if m != nil && m.Comment != nil { + return *m.Comment + } + return "" +} + +type CMsgClientToGCGetLeagueSeries struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetLeagueSeries) Reset() { *m = CMsgClientToGCGetLeagueSeries{} } +func (m *CMsgClientToGCGetLeagueSeries) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetLeagueSeries) ProtoMessage() {} +func (*CMsgClientToGCGetLeagueSeries) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{323} } + +func (m *CMsgClientToGCGetLeagueSeries) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CMsgClientToGCGetLeagueSeriesResponse struct { + Series []*CMsgClientToGCGetLeagueSeriesResponse_Series `protobuf:"bytes,1,rep,name=series" json:"series,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse) Reset() { *m = CMsgClientToGCGetLeagueSeriesResponse{} } +func (m *CMsgClientToGCGetLeagueSeriesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetLeagueSeriesResponse) ProtoMessage() {} +func (*CMsgClientToGCGetLeagueSeriesResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{324} +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse) GetSeries() []*CMsgClientToGCGetLeagueSeriesResponse_Series { + if m != nil { + return m.Series + } + return nil +} + +type CMsgClientToGCGetLeagueSeriesResponse_Series struct { + SeriesId *uint32 `protobuf:"varint,1,opt,name=series_id" json:"series_id,omitempty"` + NumGames *uint32 `protobuf:"varint,2,opt,name=num_games" json:"num_games,omitempty"` + Teams []*CMsgClientToGCGetLeagueSeriesResponse_Series_Team `protobuf:"bytes,3,rep,name=teams" json:"teams,omitempty"` + SeriesName *string `protobuf:"bytes,4,opt,name=series_name" json:"series_name,omitempty"` + PhaseName *string `protobuf:"bytes,5,opt,name=phase_name" json:"phase_name,omitempty"` + StartTime *uint32 `protobuf:"varint,6,opt,name=start_time" json:"start_time,omitempty"` + AfterSeriesId *uint32 `protobuf:"varint,7,opt,name=after_series_id" json:"after_series_id,omitempty"` + NumCompletedGames *uint32 `protobuf:"varint,8,opt,name=num_completed_games" json:"num_completed_games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) Reset() { + *m = CMsgClientToGCGetLeagueSeriesResponse_Series{} +} +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCGetLeagueSeriesResponse_Series) ProtoMessage() {} +func (*CMsgClientToGCGetLeagueSeriesResponse_Series) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{324, 0} +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetSeriesId() uint32 { + if m != nil && m.SeriesId != nil { + return *m.SeriesId + } + return 0 +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetNumGames() uint32 { + if m != nil && m.NumGames != nil { + return *m.NumGames + } + return 0 +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetTeams() []*CMsgClientToGCGetLeagueSeriesResponse_Series_Team { + if m != nil { + return m.Teams + } + return nil +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetSeriesName() string { + if m != nil && m.SeriesName != nil { + return *m.SeriesName + } + return "" +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetPhaseName() string { + if m != nil && m.PhaseName != nil { + return *m.PhaseName + } + return "" +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetAfterSeriesId() uint32 { + if m != nil && m.AfterSeriesId != nil { + return *m.AfterSeriesId + } + return 0 +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series) GetNumCompletedGames() uint32 { + if m != nil && m.NumCompletedGames != nil { + return *m.NumCompletedGames + } + return 0 +} + +type CMsgClientToGCGetLeagueSeriesResponse_Series_Team struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + TeamName *string `protobuf:"bytes,2,opt,name=team_name" json:"team_name,omitempty"` + TeamTag *string `protobuf:"bytes,3,opt,name=team_tag" json:"team_tag,omitempty"` + TeamScore *uint32 `protobuf:"varint,4,opt,name=team_score" json:"team_score,omitempty"` + TeamWins *uint32 `protobuf:"varint,5,opt,name=team_wins" json:"team_wins,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series_Team) Reset() { + *m = CMsgClientToGCGetLeagueSeriesResponse_Series_Team{} +} +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series_Team) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCGetLeagueSeriesResponse_Series_Team) ProtoMessage() {} +func (*CMsgClientToGCGetLeagueSeriesResponse_Series_Team) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{324, 0, 0} +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series_Team) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series_Team) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series_Team) GetTeamTag() string { + if m != nil && m.TeamTag != nil { + return *m.TeamTag + } + return "" +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series_Team) GetTeamScore() uint32 { + if m != nil && m.TeamScore != nil { + return *m.TeamScore + } + return 0 +} + +func (m *CMsgClientToGCGetLeagueSeriesResponse_Series_Team) GetTeamWins() uint32 { + if m != nil && m.TeamWins != nil { + return *m.TeamWins + } + return 0 +} + +type CMsgClientToGCApplyGemCombiner struct { + ItemId_1 *uint64 `protobuf:"varint,1,opt,name=item_id_1" json:"item_id_1,omitempty"` + ItemId_2 *uint64 `protobuf:"varint,2,opt,name=item_id_2" json:"item_id_2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCApplyGemCombiner) Reset() { *m = CMsgClientToGCApplyGemCombiner{} } +func (m *CMsgClientToGCApplyGemCombiner) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCApplyGemCombiner) ProtoMessage() {} +func (*CMsgClientToGCApplyGemCombiner) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{325} +} + +func (m *CMsgClientToGCApplyGemCombiner) GetItemId_1() uint64 { + if m != nil && m.ItemId_1 != nil { + return *m.ItemId_1 + } + return 0 +} + +func (m *CMsgClientToGCApplyGemCombiner) GetItemId_2() uint64 { + if m != nil && m.ItemId_2 != nil { + return *m.ItemId_2 + } + return 0 +} + +type CDummyUnbreakMessage struct { + DummyField *CMsgDOTAClearTournamentGame `protobuf:"bytes,1,opt,name=dummy_field" json:"dummy_field,omitempty"` + AnotherDummyField *ETournamentState `protobuf:"varint,2,opt,name=another_dummy_field,enum=ETournamentState,def=0" json:"another_dummy_field,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDummyUnbreakMessage) Reset() { *m = CDummyUnbreakMessage{} } +func (m *CDummyUnbreakMessage) String() string { return proto.CompactTextString(m) } +func (*CDummyUnbreakMessage) ProtoMessage() {} +func (*CDummyUnbreakMessage) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{326} } + +const Default_CDummyUnbreakMessage_AnotherDummyField ETournamentState = ETournamentState_k_ETournamentState_Unknown + +func (m *CDummyUnbreakMessage) GetDummyField() *CMsgDOTAClearTournamentGame { + if m != nil { + return m.DummyField + } + return nil +} + +func (m *CDummyUnbreakMessage) GetAnotherDummyField() ETournamentState { + if m != nil && m.AnotherDummyField != nil { + return *m.AnotherDummyField + } + return Default_CDummyUnbreakMessage_AnotherDummyField +} + +type CMsgClientToGCCreateStaticRecipe struct { + Items []*CMsgClientToGCCreateStaticRecipe_Item `protobuf:"bytes,1,rep,name=items" json:"items,omitempty"` + RecipeDefIndex *uint32 `protobuf:"varint,2,opt,name=recipe_def_index" json:"recipe_def_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCCreateStaticRecipe) Reset() { *m = CMsgClientToGCCreateStaticRecipe{} } +func (m *CMsgClientToGCCreateStaticRecipe) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCCreateStaticRecipe) ProtoMessage() {} +func (*CMsgClientToGCCreateStaticRecipe) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{327} +} + +func (m *CMsgClientToGCCreateStaticRecipe) GetItems() []*CMsgClientToGCCreateStaticRecipe_Item { + if m != nil { + return m.Items + } + return nil +} + +func (m *CMsgClientToGCCreateStaticRecipe) GetRecipeDefIndex() uint32 { + if m != nil && m.RecipeDefIndex != nil { + return *m.RecipeDefIndex + } + return 0 +} + +type CMsgClientToGCCreateStaticRecipe_Item struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + SlotId *uint32 `protobuf:"varint,2,opt,name=slot_id" json:"slot_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCCreateStaticRecipe_Item) Reset() { *m = CMsgClientToGCCreateStaticRecipe_Item{} } +func (m *CMsgClientToGCCreateStaticRecipe_Item) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCCreateStaticRecipe_Item) ProtoMessage() {} +func (*CMsgClientToGCCreateStaticRecipe_Item) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{327, 0} +} + +func (m *CMsgClientToGCCreateStaticRecipe_Item) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgClientToGCCreateStaticRecipe_Item) GetSlotId() uint32 { + if m != nil && m.SlotId != nil { + return *m.SlotId + } + return 0 +} + +type CMsgClientToGCCreateStaticRecipeResponse struct { + Response *CMsgClientToGCCreateStaticRecipeResponse_EResponse `protobuf:"varint,1,opt,name=response,enum=CMsgClientToGCCreateStaticRecipeResponse_EResponse,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCCreateStaticRecipeResponse) Reset() { + *m = CMsgClientToGCCreateStaticRecipeResponse{} +} +func (m *CMsgClientToGCCreateStaticRecipeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCCreateStaticRecipeResponse) ProtoMessage() {} +func (*CMsgClientToGCCreateStaticRecipeResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{328} +} + +const Default_CMsgClientToGCCreateStaticRecipeResponse_Response CMsgClientToGCCreateStaticRecipeResponse_EResponse = CMsgClientToGCCreateStaticRecipeResponse_eResponse_Success + +func (m *CMsgClientToGCCreateStaticRecipeResponse) GetResponse() CMsgClientToGCCreateStaticRecipeResponse_EResponse { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgClientToGCCreateStaticRecipeResponse_Response +} + +type CDOTAReplayDownloadInfo struct { + Match *CMsgDOTAMatchMinimal `protobuf:"bytes,1,opt,name=match" json:"match,omitempty"` + Title *string `protobuf:"bytes,2,opt,name=title" json:"title,omitempty"` + Description *string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"` + Size *uint32 `protobuf:"varint,4,opt,name=size" json:"size,omitempty"` + Tags []string `protobuf:"bytes,5,rep,name=tags" json:"tags,omitempty"` + ExistsOnDisk *bool `protobuf:"varint,6,opt,name=exists_on_disk" json:"exists_on_disk,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTAReplayDownloadInfo) Reset() { *m = CDOTAReplayDownloadInfo{} } +func (m *CDOTAReplayDownloadInfo) String() string { return proto.CompactTextString(m) } +func (*CDOTAReplayDownloadInfo) ProtoMessage() {} +func (*CDOTAReplayDownloadInfo) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{329} } + +func (m *CDOTAReplayDownloadInfo) GetMatch() *CMsgDOTAMatchMinimal { + if m != nil { + return m.Match + } + return nil +} + +func (m *CDOTAReplayDownloadInfo) GetTitle() string { + if m != nil && m.Title != nil { + return *m.Title + } + return "" +} + +func (m *CDOTAReplayDownloadInfo) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CDOTAReplayDownloadInfo) GetSize() uint32 { + if m != nil && m.Size != nil { + return *m.Size + } + return 0 +} + +func (m *CDOTAReplayDownloadInfo) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *CDOTAReplayDownloadInfo) GetExistsOnDisk() bool { + if m != nil && m.ExistsOnDisk != nil { + return *m.ExistsOnDisk + } + return false +} + +type CDOTAReplayDownloadInfo_Highlight struct { + Timestamp *uint32 `protobuf:"varint,1,opt,name=timestamp" json:"timestamp,omitempty"` + Description *string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTAReplayDownloadInfo_Highlight) Reset() { *m = CDOTAReplayDownloadInfo_Highlight{} } +func (m *CDOTAReplayDownloadInfo_Highlight) String() string { return proto.CompactTextString(m) } +func (*CDOTAReplayDownloadInfo_Highlight) ProtoMessage() {} +func (*CDOTAReplayDownloadInfo_Highlight) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{329, 0} +} + +func (m *CDOTAReplayDownloadInfo_Highlight) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CDOTAReplayDownloadInfo_Highlight) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +type CDOTABroadcasterInfo struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ServerSteamId *uint64 `protobuf:"fixed64,2,opt,name=server_steam_id" json:"server_steam_id,omitempty"` + Live *bool `protobuf:"varint,3,opt,name=live" json:"live,omitempty"` + TeamNameRadiant *string `protobuf:"bytes,4,opt,name=team_name_radiant" json:"team_name_radiant,omitempty"` + TeamNameDire *string `protobuf:"bytes,5,opt,name=team_name_dire" json:"team_name_dire,omitempty"` + StageName *string `protobuf:"bytes,6,opt,name=stage_name" json:"stage_name,omitempty"` + SeriesGame *uint32 `protobuf:"varint,7,opt,name=series_game" json:"series_game,omitempty"` + SeriesType *uint32 `protobuf:"varint,8,opt,name=series_type" json:"series_type,omitempty"` + UpcomingBroadcastTimestamp *uint32 `protobuf:"varint,9,opt,name=upcoming_broadcast_timestamp" json:"upcoming_broadcast_timestamp,omitempty"` + AllowLiveVideo *bool `protobuf:"varint,10,opt,name=allow_live_video" json:"allow_live_video,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTABroadcasterInfo) Reset() { *m = CDOTABroadcasterInfo{} } +func (m *CDOTABroadcasterInfo) String() string { return proto.CompactTextString(m) } +func (*CDOTABroadcasterInfo) ProtoMessage() {} +func (*CDOTABroadcasterInfo) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{330} } + +func (m *CDOTABroadcasterInfo) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CDOTABroadcasterInfo) GetServerSteamId() uint64 { + if m != nil && m.ServerSteamId != nil { + return *m.ServerSteamId + } + return 0 +} + +func (m *CDOTABroadcasterInfo) GetLive() bool { + if m != nil && m.Live != nil { + return *m.Live + } + return false +} + +func (m *CDOTABroadcasterInfo) GetTeamNameRadiant() string { + if m != nil && m.TeamNameRadiant != nil { + return *m.TeamNameRadiant + } + return "" +} + +func (m *CDOTABroadcasterInfo) GetTeamNameDire() string { + if m != nil && m.TeamNameDire != nil { + return *m.TeamNameDire + } + return "" +} + +func (m *CDOTABroadcasterInfo) GetStageName() string { + if m != nil && m.StageName != nil { + return *m.StageName + } + return "" +} + +func (m *CDOTABroadcasterInfo) GetSeriesGame() uint32 { + if m != nil && m.SeriesGame != nil { + return *m.SeriesGame + } + return 0 +} + +func (m *CDOTABroadcasterInfo) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +func (m *CDOTABroadcasterInfo) GetUpcomingBroadcastTimestamp() uint32 { + if m != nil && m.UpcomingBroadcastTimestamp != nil { + return *m.UpcomingBroadcastTimestamp + } + return 0 +} + +func (m *CDOTABroadcasterInfo) GetAllowLiveVideo() bool { + if m != nil && m.AllowLiveVideo != nil { + return *m.AllowLiveVideo + } + return false +} + +type CMsgClientToGCH264Unsupported struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCH264Unsupported) Reset() { *m = CMsgClientToGCH264Unsupported{} } +func (m *CMsgClientToGCH264Unsupported) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCH264Unsupported) ProtoMessage() {} +func (*CMsgClientToGCH264Unsupported) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{331} } + +type CMsgClientToGCRequestH264Support struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCRequestH264Support) Reset() { *m = CMsgClientToGCRequestH264Support{} } +func (m *CMsgClientToGCRequestH264Support) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCRequestH264Support) ProtoMessage() {} +func (*CMsgClientToGCRequestH264Support) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{332} +} + +type CMsgClientToGCGetQuestProgress struct { + QuestIds []uint32 `protobuf:"varint,1,rep,name=quest_ids" json:"quest_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetQuestProgress) Reset() { *m = CMsgClientToGCGetQuestProgress{} } +func (m *CMsgClientToGCGetQuestProgress) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetQuestProgress) ProtoMessage() {} +func (*CMsgClientToGCGetQuestProgress) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{333} +} + +func (m *CMsgClientToGCGetQuestProgress) GetQuestIds() []uint32 { + if m != nil { + return m.QuestIds + } + return nil +} + +type CMsgClientToGCGetQuestProgressResponse struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + Quests []*CMsgClientToGCGetQuestProgressResponse_Quest `protobuf:"bytes,2,rep,name=quests" json:"quests,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetQuestProgressResponse) Reset() { + *m = CMsgClientToGCGetQuestProgressResponse{} +} +func (m *CMsgClientToGCGetQuestProgressResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCGetQuestProgressResponse) ProtoMessage() {} +func (*CMsgClientToGCGetQuestProgressResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{334} +} + +func (m *CMsgClientToGCGetQuestProgressResponse) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +func (m *CMsgClientToGCGetQuestProgressResponse) GetQuests() []*CMsgClientToGCGetQuestProgressResponse_Quest { + if m != nil { + return m.Quests + } + return nil +} + +type CMsgClientToGCGetQuestProgressResponse_Challenge struct { + ChallengeId *uint32 `protobuf:"varint,1,opt,name=challenge_id" json:"challenge_id,omitempty"` + TimeCompleted *uint32 `protobuf:"varint,2,opt,name=time_completed" json:"time_completed,omitempty"` + Attempts *uint32 `protobuf:"varint,3,opt,name=attempts" json:"attempts,omitempty"` + HeroId *uint32 `protobuf:"varint,4,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Challenge) Reset() { + *m = CMsgClientToGCGetQuestProgressResponse_Challenge{} +} +func (m *CMsgClientToGCGetQuestProgressResponse_Challenge) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCGetQuestProgressResponse_Challenge) ProtoMessage() {} +func (*CMsgClientToGCGetQuestProgressResponse_Challenge) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{334, 0} +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Challenge) GetChallengeId() uint32 { + if m != nil && m.ChallengeId != nil { + return *m.ChallengeId + } + return 0 +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Challenge) GetTimeCompleted() uint32 { + if m != nil && m.TimeCompleted != nil { + return *m.TimeCompleted + } + return 0 +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Challenge) GetAttempts() uint32 { + if m != nil && m.Attempts != nil { + return *m.Attempts + } + return 0 +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Challenge) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgClientToGCGetQuestProgressResponse_Quest struct { + QuestId *uint32 `protobuf:"varint,1,opt,name=quest_id" json:"quest_id,omitempty"` + CompletedChallenges []*CMsgClientToGCGetQuestProgressResponse_Challenge `protobuf:"bytes,2,rep,name=completed_challenges" json:"completed_challenges,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Quest) Reset() { + *m = CMsgClientToGCGetQuestProgressResponse_Quest{} +} +func (m *CMsgClientToGCGetQuestProgressResponse_Quest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientToGCGetQuestProgressResponse_Quest) ProtoMessage() {} +func (*CMsgClientToGCGetQuestProgressResponse_Quest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{334, 1} +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Quest) GetQuestId() uint32 { + if m != nil && m.QuestId != nil { + return *m.QuestId + } + return 0 +} + +func (m *CMsgClientToGCGetQuestProgressResponse_Quest) GetCompletedChallenges() []*CMsgClientToGCGetQuestProgressResponse_Challenge { + if m != nil { + return m.CompletedChallenges + } + return nil +} + +type CMsgGCToClientMatchSignedOut struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientMatchSignedOut) Reset() { *m = CMsgGCToClientMatchSignedOut{} } +func (m *CMsgGCToClientMatchSignedOut) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientMatchSignedOut) ProtoMessage() {} +func (*CMsgGCToClientMatchSignedOut) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{335} } + +func (m *CMsgGCToClientMatchSignedOut) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +type CMsgGCGetHeroStatsHistory struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCGetHeroStatsHistory) Reset() { *m = CMsgGCGetHeroStatsHistory{} } +func (m *CMsgGCGetHeroStatsHistory) String() string { return proto.CompactTextString(m) } +func (*CMsgGCGetHeroStatsHistory) ProtoMessage() {} +func (*CMsgGCGetHeroStatsHistory) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{336} } + +func (m *CMsgGCGetHeroStatsHistory) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgGCGetHeroStatsHistoryResponse struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + Records []*CMsgDOTASDOHeroStatsHistory `protobuf:"bytes,2,rep,name=records" json:"records,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCGetHeroStatsHistoryResponse) Reset() { *m = CMsgGCGetHeroStatsHistoryResponse{} } +func (m *CMsgGCGetHeroStatsHistoryResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCGetHeroStatsHistoryResponse) ProtoMessage() {} +func (*CMsgGCGetHeroStatsHistoryResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{337} +} + +func (m *CMsgGCGetHeroStatsHistoryResponse) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgGCGetHeroStatsHistoryResponse) GetRecords() []*CMsgDOTASDOHeroStatsHistory { + if m != nil { + return m.Records + } + return nil +} + +type CMsgClientToGCPrivateChatInvite struct { + PrivateChatChannelName *string `protobuf:"bytes,1,opt,name=private_chat_channel_name" json:"private_chat_channel_name,omitempty"` + InvitedAccountId *uint32 `protobuf:"varint,2,opt,name=invited_account_id" json:"invited_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCPrivateChatInvite) Reset() { *m = CMsgClientToGCPrivateChatInvite{} } +func (m *CMsgClientToGCPrivateChatInvite) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCPrivateChatInvite) ProtoMessage() {} +func (*CMsgClientToGCPrivateChatInvite) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{338} +} + +func (m *CMsgClientToGCPrivateChatInvite) GetPrivateChatChannelName() string { + if m != nil && m.PrivateChatChannelName != nil { + return *m.PrivateChatChannelName + } + return "" +} + +func (m *CMsgClientToGCPrivateChatInvite) GetInvitedAccountId() uint32 { + if m != nil && m.InvitedAccountId != nil { + return *m.InvitedAccountId + } + return 0 +} + +type CMsgClientToGCPrivateChatKick struct { + PrivateChatChannelName *string `protobuf:"bytes,1,opt,name=private_chat_channel_name" json:"private_chat_channel_name,omitempty"` + KickAccountId *uint32 `protobuf:"varint,2,opt,name=kick_account_id" json:"kick_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCPrivateChatKick) Reset() { *m = CMsgClientToGCPrivateChatKick{} } +func (m *CMsgClientToGCPrivateChatKick) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCPrivateChatKick) ProtoMessage() {} +func (*CMsgClientToGCPrivateChatKick) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{339} } + +func (m *CMsgClientToGCPrivateChatKick) GetPrivateChatChannelName() string { + if m != nil && m.PrivateChatChannelName != nil { + return *m.PrivateChatChannelName + } + return "" +} + +func (m *CMsgClientToGCPrivateChatKick) GetKickAccountId() uint32 { + if m != nil && m.KickAccountId != nil { + return *m.KickAccountId + } + return 0 +} + +type CMsgClientToGCPrivateChatPromote struct { + PrivateChatChannelName *string `protobuf:"bytes,1,opt,name=private_chat_channel_name" json:"private_chat_channel_name,omitempty"` + PromoteAccountId *uint32 `protobuf:"varint,2,opt,name=promote_account_id" json:"promote_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCPrivateChatPromote) Reset() { *m = CMsgClientToGCPrivateChatPromote{} } +func (m *CMsgClientToGCPrivateChatPromote) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCPrivateChatPromote) ProtoMessage() {} +func (*CMsgClientToGCPrivateChatPromote) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{340} +} + +func (m *CMsgClientToGCPrivateChatPromote) GetPrivateChatChannelName() string { + if m != nil && m.PrivateChatChannelName != nil { + return *m.PrivateChatChannelName + } + return "" +} + +func (m *CMsgClientToGCPrivateChatPromote) GetPromoteAccountId() uint32 { + if m != nil && m.PromoteAccountId != nil { + return *m.PromoteAccountId + } + return 0 +} + +type CMsgClientToGCPrivateChatDemote struct { + PrivateChatChannelName *string `protobuf:"bytes,1,opt,name=private_chat_channel_name" json:"private_chat_channel_name,omitempty"` + DemoteAccountId *uint32 `protobuf:"varint,2,opt,name=demote_account_id" json:"demote_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCPrivateChatDemote) Reset() { *m = CMsgClientToGCPrivateChatDemote{} } +func (m *CMsgClientToGCPrivateChatDemote) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCPrivateChatDemote) ProtoMessage() {} +func (*CMsgClientToGCPrivateChatDemote) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{341} +} + +func (m *CMsgClientToGCPrivateChatDemote) GetPrivateChatChannelName() string { + if m != nil && m.PrivateChatChannelName != nil { + return *m.PrivateChatChannelName + } + return "" +} + +func (m *CMsgClientToGCPrivateChatDemote) GetDemoteAccountId() uint32 { + if m != nil && m.DemoteAccountId != nil { + return *m.DemoteAccountId + } + return 0 +} + +type CMsgGCToClientPrivateChatResponse struct { + PrivateChatChannelName *string `protobuf:"bytes,1,opt,name=private_chat_channel_name" json:"private_chat_channel_name,omitempty"` + Result *CMsgGCToClientPrivateChatResponse_Result `protobuf:"varint,2,opt,name=result,enum=CMsgGCToClientPrivateChatResponse_Result,def=0" json:"result,omitempty"` + Username *string `protobuf:"bytes,3,opt,name=username" json:"username,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientPrivateChatResponse) Reset() { *m = CMsgGCToClientPrivateChatResponse{} } +func (m *CMsgGCToClientPrivateChatResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientPrivateChatResponse) ProtoMessage() {} +func (*CMsgGCToClientPrivateChatResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{342} +} + +const Default_CMsgGCToClientPrivateChatResponse_Result CMsgGCToClientPrivateChatResponse_Result = CMsgGCToClientPrivateChatResponse_SUCCESS + +func (m *CMsgGCToClientPrivateChatResponse) GetPrivateChatChannelName() string { + if m != nil && m.PrivateChatChannelName != nil { + return *m.PrivateChatChannelName + } + return "" +} + +func (m *CMsgGCToClientPrivateChatResponse) GetResult() CMsgGCToClientPrivateChatResponse_Result { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgGCToClientPrivateChatResponse_Result +} + +func (m *CMsgGCToClientPrivateChatResponse) GetUsername() string { + if m != nil && m.Username != nil { + return *m.Username + } + return "" +} + +type CMsgClientToGCPrivateChatInfoRequest struct { + PrivateChatChannelName *string `protobuf:"bytes,1,opt,name=private_chat_channel_name" json:"private_chat_channel_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCPrivateChatInfoRequest) Reset() { *m = CMsgClientToGCPrivateChatInfoRequest{} } +func (m *CMsgClientToGCPrivateChatInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCPrivateChatInfoRequest) ProtoMessage() {} +func (*CMsgClientToGCPrivateChatInfoRequest) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{343} +} + +func (m *CMsgClientToGCPrivateChatInfoRequest) GetPrivateChatChannelName() string { + if m != nil && m.PrivateChatChannelName != nil { + return *m.PrivateChatChannelName + } + return "" +} + +type CMsgGCToClientPrivateChatInfoResponse struct { + PrivateChatChannelName *string `protobuf:"bytes,1,opt,name=private_chat_channel_name" json:"private_chat_channel_name,omitempty"` + Members []*CMsgGCToClientPrivateChatInfoResponse_Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` + Creator *uint32 `protobuf:"varint,3,opt,name=creator" json:"creator,omitempty"` + CreationDate *uint32 `protobuf:"varint,4,opt,name=creation_date" json:"creation_date,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientPrivateChatInfoResponse) Reset() { *m = CMsgGCToClientPrivateChatInfoResponse{} } +func (m *CMsgGCToClientPrivateChatInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientPrivateChatInfoResponse) ProtoMessage() {} +func (*CMsgGCToClientPrivateChatInfoResponse) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{344} +} + +func (m *CMsgGCToClientPrivateChatInfoResponse) GetPrivateChatChannelName() string { + if m != nil && m.PrivateChatChannelName != nil { + return *m.PrivateChatChannelName + } + return "" +} + +func (m *CMsgGCToClientPrivateChatInfoResponse) GetMembers() []*CMsgGCToClientPrivateChatInfoResponse_Member { + if m != nil { + return m.Members + } + return nil +} + +func (m *CMsgGCToClientPrivateChatInfoResponse) GetCreator() uint32 { + if m != nil && m.Creator != nil { + return *m.Creator + } + return 0 +} + +func (m *CMsgGCToClientPrivateChatInfoResponse) GetCreationDate() uint32 { + if m != nil && m.CreationDate != nil { + return *m.CreationDate + } + return 0 +} + +type CMsgGCToClientPrivateChatInfoResponse_Member struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Status *uint32 `protobuf:"varint,3,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientPrivateChatInfoResponse_Member) Reset() { + *m = CMsgGCToClientPrivateChatInfoResponse_Member{} +} +func (m *CMsgGCToClientPrivateChatInfoResponse_Member) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToClientPrivateChatInfoResponse_Member) ProtoMessage() {} +func (*CMsgGCToClientPrivateChatInfoResponse_Member) Descriptor() ([]byte, []int) { + return dota_client_fileDescriptor0, []int{344, 0} +} + +func (m *CMsgGCToClientPrivateChatInfoResponse_Member) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToClientPrivateChatInfoResponse_Member) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgGCToClientPrivateChatInfoResponse_Member) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CMsgPlayerBehaviorReport struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + MatchId *uint64 `protobuf:"varint,2,opt,name=match_id" json:"match_id,omitempty"` + SeqNum *uint32 `protobuf:"varint,3,opt,name=seq_num" json:"seq_num,omitempty"` + Reasons *uint32 `protobuf:"varint,4,opt,name=reasons" json:"reasons,omitempty"` + MatchesInReport *uint32 `protobuf:"varint,5,opt,name=matches_in_report" json:"matches_in_report,omitempty"` + MatchesClean *uint32 `protobuf:"varint,6,opt,name=matches_clean" json:"matches_clean,omitempty"` + MatchesReported *uint32 `protobuf:"varint,7,opt,name=matches_reported" json:"matches_reported,omitempty"` + MatchesAbandoned *uint32 `protobuf:"varint,8,opt,name=matches_abandoned" json:"matches_abandoned,omitempty"` + ReportsCount *uint32 `protobuf:"varint,9,opt,name=reports_count" json:"reports_count,omitempty"` + ReportsParties *uint32 `protobuf:"varint,10,opt,name=reports_parties" json:"reports_parties,omitempty"` + CommendCount *uint32 `protobuf:"varint,11,opt,name=commend_count" json:"commend_count,omitempty"` + EndScore *uint32 `protobuf:"varint,13,opt,name=end_score" json:"end_score,omitempty"` + ClientAcknowledged *bool `protobuf:"varint,100,opt,name=client_acknowledged" json:"client_acknowledged,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPlayerBehaviorReport) Reset() { *m = CMsgPlayerBehaviorReport{} } +func (m *CMsgPlayerBehaviorReport) String() string { return proto.CompactTextString(m) } +func (*CMsgPlayerBehaviorReport) ProtoMessage() {} +func (*CMsgPlayerBehaviorReport) Descriptor() ([]byte, []int) { return dota_client_fileDescriptor0, []int{345} } + +func (m *CMsgPlayerBehaviorReport) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetSeqNum() uint32 { + if m != nil && m.SeqNum != nil { + return *m.SeqNum + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetReasons() uint32 { + if m != nil && m.Reasons != nil { + return *m.Reasons + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetMatchesInReport() uint32 { + if m != nil && m.MatchesInReport != nil { + return *m.MatchesInReport + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetMatchesClean() uint32 { + if m != nil && m.MatchesClean != nil { + return *m.MatchesClean + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetMatchesReported() uint32 { + if m != nil && m.MatchesReported != nil { + return *m.MatchesReported + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetMatchesAbandoned() uint32 { + if m != nil && m.MatchesAbandoned != nil { + return *m.MatchesAbandoned + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetReportsCount() uint32 { + if m != nil && m.ReportsCount != nil { + return *m.ReportsCount + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetReportsParties() uint32 { + if m != nil && m.ReportsParties != nil { + return *m.ReportsParties + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetCommendCount() uint32 { + if m != nil && m.CommendCount != nil { + return *m.CommendCount + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetEndScore() uint32 { + if m != nil && m.EndScore != nil { + return *m.EndScore + } + return 0 +} + +func (m *CMsgPlayerBehaviorReport) GetClientAcknowledged() bool { + if m != nil && m.ClientAcknowledged != nil { + return *m.ClientAcknowledged + } + return false +} + +func init() { + proto.RegisterType((*CMsgStartFindingMatch)(nil), "CMsgStartFindingMatch") + proto.RegisterType((*CMsgStopFindingMatch)(nil), "CMsgStopFindingMatch") + proto.RegisterType((*CMsgReadyUp)(nil), "CMsgReadyUp") + proto.RegisterType((*CMsgReadyUpStatus)(nil), "CMsgReadyUpStatus") + proto.RegisterType((*CSourceTVGameSmall)(nil), "CSourceTVGameSmall") + proto.RegisterType((*CSourceTVGameSmall_Player)(nil), "CSourceTVGameSmall.Player") + proto.RegisterType((*CMsgClientToGCFindTopSourceTVGames)(nil), "CMsgClientToGCFindTopSourceTVGames") + proto.RegisterType((*CMsgGCToClientFindTopSourceTVGamesResponse)(nil), "CMsgGCToClientFindTopSourceTVGamesResponse") + proto.RegisterType((*CMsgClientToGCTopMatchesRequest)(nil), "CMsgClientToGCTopMatchesRequest") + proto.RegisterType((*CMsgClientToGCTopLeagueMatchesRequest)(nil), "CMsgClientToGCTopLeagueMatchesRequest") + proto.RegisterType((*CMsgClientToGCTopFriendMatchesRequest)(nil), "CMsgClientToGCTopFriendMatchesRequest") + proto.RegisterType((*CMsgClientToGCMatchesMinimalRequest)(nil), "CMsgClientToGCMatchesMinimalRequest") + proto.RegisterType((*CMsgClientToGCMatchesMinimalResponse)(nil), "CMsgClientToGCMatchesMinimalResponse") + proto.RegisterType((*CMsgGCToClientTopLeagueMatchesResponse)(nil), "CMsgGCToClientTopLeagueMatchesResponse") + proto.RegisterType((*CMsgGCToClientTopFriendMatchesResponse)(nil), "CMsgGCToClientTopFriendMatchesResponse") + proto.RegisterType((*CMsgClientToGCFindTopMatches)(nil), "CMsgClientToGCFindTopMatches") + proto.RegisterType((*CMsgGCToClientFindTopLeagueMatchesResponse)(nil), "CMsgGCToClientFindTopLeagueMatchesResponse") + proto.RegisterType((*CMsgSpectateFriendGame)(nil), "CMsgSpectateFriendGame") + proto.RegisterType((*CMsgSpectateFriendGameResponse)(nil), "CMsgSpectateFriendGameResponse") + proto.RegisterType((*CMsgAbandonCurrentGame)(nil), "CMsgAbandonCurrentGame") + proto.RegisterType((*CMsgClientSuspended)(nil), "CMsgClientSuspended") + proto.RegisterType((*CMsgPracticeLobbySetDetails)(nil), "CMsgPracticeLobbySetDetails") + proto.RegisterType((*CMsgPracticeLobbyCreate)(nil), "CMsgPracticeLobbyCreate") + proto.RegisterType((*CMsgPracticeLobbyCreate_SaveGame)(nil), "CMsgPracticeLobbyCreate.SaveGame") + proto.RegisterType((*CMsgPracticeLobbySetTeamSlot)(nil), "CMsgPracticeLobbySetTeamSlot") + proto.RegisterType((*CMsgPracticeLobbySetCoach)(nil), "CMsgPracticeLobbySetCoach") + proto.RegisterType((*CMsgPracticeLobbyJoinBroadcastChannel)(nil), "CMsgPracticeLobbyJoinBroadcastChannel") + proto.RegisterType((*CMsgPracticeLobbyCloseBroadcastChannel)(nil), "CMsgPracticeLobbyCloseBroadcastChannel") + proto.RegisterType((*CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus)(nil), "CMsgPracticeLobbyToggleBroadcastChannelCameramanStatus") + proto.RegisterType((*CMsgPracticeLobbyKick)(nil), "CMsgPracticeLobbyKick") + proto.RegisterType((*CMsgPracticeLobbyKickFromTeam)(nil), "CMsgPracticeLobbyKickFromTeam") + proto.RegisterType((*CMsgPracticeLobbyLeave)(nil), "CMsgPracticeLobbyLeave") + proto.RegisterType((*CMsgPracticeLobbyLaunch)(nil), "CMsgPracticeLobbyLaunch") + proto.RegisterType((*CMsgApplyTeamToPracticeLobby)(nil), "CMsgApplyTeamToPracticeLobby") + proto.RegisterType((*CMsgClearPracticeLobbyTeam)(nil), "CMsgClearPracticeLobbyTeam") + proto.RegisterType((*CMsgPracticeLobbyList)(nil), "CMsgPracticeLobbyList") + proto.RegisterType((*CMsgPracticeLobbyListResponseEntry)(nil), "CMsgPracticeLobbyListResponseEntry") + proto.RegisterType((*CMsgPracticeLobbyListResponseEntry_CLobbyMember)(nil), "CMsgPracticeLobbyListResponseEntry.CLobbyMember") + proto.RegisterType((*CMsgPracticeLobbyListResponse)(nil), "CMsgPracticeLobbyListResponse") + proto.RegisterType((*CMsgLobbyList)(nil), "CMsgLobbyList") + proto.RegisterType((*CMsgLobbyListResponse)(nil), "CMsgLobbyListResponse") + proto.RegisterType((*CMsgPracticeLobbyJoin)(nil), "CMsgPracticeLobbyJoin") + proto.RegisterType((*CMsgPracticeLobbyJoinResponse)(nil), "CMsgPracticeLobbyJoinResponse") + proto.RegisterType((*CMsgFriendPracticeLobbyListRequest)(nil), "CMsgFriendPracticeLobbyListRequest") + proto.RegisterType((*CMsgFriendPracticeLobbyListResponse)(nil), "CMsgFriendPracticeLobbyListResponse") + proto.RegisterType((*CMsgGuildmatePracticeLobbyListRequest)(nil), "CMsgGuildmatePracticeLobbyListRequest") + proto.RegisterType((*CMsgGuildmatePracticeLobbyListResponse)(nil), "CMsgGuildmatePracticeLobbyListResponse") + proto.RegisterType((*CMsgJoinableCustomGameModesRequest)(nil), "CMsgJoinableCustomGameModesRequest") + proto.RegisterType((*CMsgJoinableCustomGameModesResponseEntry)(nil), "CMsgJoinableCustomGameModesResponseEntry") + proto.RegisterType((*CMsgJoinableCustomGameModesResponse)(nil), "CMsgJoinableCustomGameModesResponse") + proto.RegisterType((*CMsgJoinableCustomLobbiesRequest)(nil), "CMsgJoinableCustomLobbiesRequest") + proto.RegisterType((*CMsgJoinableCustomLobbiesResponseEntry)(nil), "CMsgJoinableCustomLobbiesResponseEntry") + proto.RegisterType((*CMsgJoinableCustomLobbiesResponse)(nil), "CMsgJoinableCustomLobbiesResponse") + proto.RegisterType((*CMsgQuickJoinCustomLobby)(nil), "CMsgQuickJoinCustomLobby") + proto.RegisterType((*CMsgQuickJoinCustomLobby_LegacyRegionPing)(nil), "CMsgQuickJoinCustomLobby.LegacyRegionPing") + proto.RegisterType((*CMsgQuickJoinCustomLobbyResponse)(nil), "CMsgQuickJoinCustomLobbyResponse") + proto.RegisterType((*CMsgBotGameCreate)(nil), "CMsgBotGameCreate") + proto.RegisterType((*CMsgCustomGameCreate)(nil), "CMsgCustomGameCreate") + proto.RegisterType((*CMsgEventGameCreate)(nil), "CMsgEventGameCreate") + proto.RegisterType((*CMsgRequestInternationalTicket)(nil), "CMsgRequestInternationalTicket") + proto.RegisterType((*CMsgBalancedShuffleLobby)(nil), "CMsgBalancedShuffleLobby") + proto.RegisterType((*CMsgInitialQuestionnaireResponse)(nil), "CMsgInitialQuestionnaireResponse") + proto.RegisterType((*CMsgDOTAMatch)(nil), "CMsgDOTAMatch") + proto.RegisterType((*CMsgDOTAMatch_Player)(nil), "CMsgDOTAMatch.Player") + proto.RegisterType((*CMsgDOTAMatch_Player_CustomGameData)(nil), "CMsgDOTAMatch.Player.CustomGameData") + proto.RegisterType((*CMsgDOTAMatch_BroadcasterInfo)(nil), "CMsgDOTAMatch.BroadcasterInfo") + proto.RegisterType((*CMsgDOTAMatch_BroadcasterChannel)(nil), "CMsgDOTAMatch.BroadcasterChannel") + proto.RegisterType((*CMsgDOTAMatch_CustomGameData)(nil), "CMsgDOTAMatch.CustomGameData") + proto.RegisterType((*CMsgDOTAPlayerMatchHistory)(nil), "CMsgDOTAPlayerMatchHistory") + proto.RegisterType((*CMsgDOTAMatchMinimal)(nil), "CMsgDOTAMatchMinimal") + proto.RegisterType((*CMsgDOTAMatchMinimal_Player)(nil), "CMsgDOTAMatchMinimal.Player") + proto.RegisterType((*CMsgDOTAMatchMinimal_League)(nil), "CMsgDOTAMatchMinimal.League") + proto.RegisterType((*CMsgDOTAMatchHistoryFilter)(nil), "CMsgDOTAMatchHistoryFilter") + proto.RegisterType((*CMsgDOTARequestMatches)(nil), "CMsgDOTARequestMatches") + proto.RegisterType((*CMsgDOTARequestMatchesResponse)(nil), "CMsgDOTARequestMatchesResponse") + proto.RegisterType((*CMsgDOTARequestMatchesResponse_Series)(nil), "CMsgDOTARequestMatchesResponse.Series") + proto.RegisterType((*CMsgDOTAPopup)(nil), "CMsgDOTAPopup") + proto.RegisterType((*CMsgDOTATeamMemberSDO)(nil), "CMsgDOTATeamMemberSDO") + proto.RegisterType((*CMsgDOTATeamAdminSDO)(nil), "CMsgDOTATeamAdminSDO") + proto.RegisterType((*CMsgDOTATeamMember)(nil), "CMsgDOTATeamMember") + proto.RegisterType((*CMsgDOTATeam)(nil), "CMsgDOTATeam") + proto.RegisterType((*CMsgDOTACreateTeam)(nil), "CMsgDOTACreateTeam") + proto.RegisterType((*CMsgDOTACreateTeamResponse)(nil), "CMsgDOTACreateTeamResponse") + proto.RegisterType((*CMsgDOTAEditTeam)(nil), "CMsgDOTAEditTeam") + proto.RegisterType((*CMsgDOTAEditTeamLogo)(nil), "CMsgDOTAEditTeamLogo") + proto.RegisterType((*CMsgDOTAEditTeamLogoResponse)(nil), "CMsgDOTAEditTeamLogoResponse") + proto.RegisterType((*CMsgDOTAEditTeamDetails)(nil), "CMsgDOTAEditTeamDetails") + proto.RegisterType((*CMsgDOTAEditTeamDetailsResponse)(nil), "CMsgDOTAEditTeamDetailsResponse") + proto.RegisterType((*CMsgDOTADisbandTeam)(nil), "CMsgDOTADisbandTeam") + proto.RegisterType((*CMsgDOTADisbandTeamResponse)(nil), "CMsgDOTADisbandTeamResponse") + proto.RegisterType((*CMsgDOTARequestTeamData)(nil), "CMsgDOTARequestTeamData") + proto.RegisterType((*CMsgDOTARequestTeamDataResponse)(nil), "CMsgDOTARequestTeamDataResponse") + proto.RegisterType((*CMsgDOTATeamData)(nil), "CMsgDOTATeamData") + proto.RegisterType((*CMsgDOTATeamProfileRequest)(nil), "CMsgDOTATeamProfileRequest") + proto.RegisterType((*CMsgDOTATeamMemberProfileRequest)(nil), "CMsgDOTATeamMemberProfileRequest") + proto.RegisterType((*CMsgDOTATeamIDByNameRequest)(nil), "CMsgDOTATeamIDByNameRequest") + proto.RegisterType((*CMsgDOTATeamIDByNameResponse)(nil), "CMsgDOTATeamIDByNameResponse") + proto.RegisterType((*CMsgDOTATeamProfileResponse)(nil), "CMsgDOTATeamProfileResponse") + proto.RegisterType((*CMsgDOTAProTeamListRequest)(nil), "CMsgDOTAProTeamListRequest") + proto.RegisterType((*CMsgDOTAProTeamListResponse)(nil), "CMsgDOTAProTeamListResponse") + proto.RegisterType((*CMsgDOTAProTeamListResponse_TeamEntry)(nil), "CMsgDOTAProTeamListResponse.TeamEntry") + proto.RegisterType((*CMsgDOTATeamInvite_InviterToGC)(nil), "CMsgDOTATeamInvite_InviterToGC") + proto.RegisterType((*CMsgDOTATeamInvite_GCImmediateResponseToInviter)(nil), "CMsgDOTATeamInvite_GCImmediateResponseToInviter") + proto.RegisterType((*CMsgDOTATeamInvite_GCRequestToInvitee)(nil), "CMsgDOTATeamInvite_GCRequestToInvitee") + proto.RegisterType((*CMsgDOTATeamInvite_InviteeResponseToGC)(nil), "CMsgDOTATeamInvite_InviteeResponseToGC") + proto.RegisterType((*CMsgDOTATeamInvite_GCResponseToInviter)(nil), "CMsgDOTATeamInvite_GCResponseToInviter") + proto.RegisterType((*CMsgDOTATeamInvite_GCResponseToInvitee)(nil), "CMsgDOTATeamInvite_GCResponseToInvitee") + proto.RegisterType((*CMsgDOTATeamOnProfile)(nil), "CMsgDOTATeamOnProfile") + proto.RegisterType((*CMsgDOTAKickTeamMember)(nil), "CMsgDOTAKickTeamMember") + proto.RegisterType((*CMsgDOTAKickTeamMemberResponse)(nil), "CMsgDOTAKickTeamMemberResponse") + proto.RegisterType((*CMsgDOTATransferTeamAdmin)(nil), "CMsgDOTATransferTeamAdmin") + proto.RegisterType((*CMsgDOTATransferTeamAdminResponse)(nil), "CMsgDOTATransferTeamAdminResponse") + proto.RegisterType((*CMsgDOTALeaveTeam)(nil), "CMsgDOTALeaveTeam") + proto.RegisterType((*CMsgDOTALeaveTeamResponse)(nil), "CMsgDOTALeaveTeamResponse") + proto.RegisterType((*CMsgDOTABetaParticipation)(nil), "CMsgDOTABetaParticipation") + proto.RegisterType((*CMsgDOTAJoinChatChannel)(nil), "CMsgDOTAJoinChatChannel") + proto.RegisterType((*CMsgDOTALeaveChatChannel)(nil), "CMsgDOTALeaveChatChannel") + proto.RegisterType((*CMsgDOTAClientIgnoredUser)(nil), "CMsgDOTAClientIgnoredUser") + proto.RegisterType((*CMsgDOTAChatMessage)(nil), "CMsgDOTAChatMessage") + proto.RegisterType((*CMsgDOTAChatMessage_DiceRoll)(nil), "CMsgDOTAChatMessage.DiceRoll") + proto.RegisterType((*CMsgDOTAChatMember)(nil), "CMsgDOTAChatMember") + proto.RegisterType((*CMsgDOTAJoinChatChannelResponse)(nil), "CMsgDOTAJoinChatChannelResponse") + proto.RegisterType((*CMsgDOTAChatChannelFullUpdate)(nil), "CMsgDOTAChatChannelFullUpdate") + proto.RegisterType((*CMsgDOTAOtherJoinedChatChannel)(nil), "CMsgDOTAOtherJoinedChatChannel") + proto.RegisterType((*CMsgDOTAOtherLeftChatChannel)(nil), "CMsgDOTAOtherLeftChatChannel") + proto.RegisterType((*CMsgDOTAChatChannelMemberUpdate)(nil), "CMsgDOTAChatChannelMemberUpdate") + proto.RegisterType((*CMsgDOTAChatChannelMemberUpdate_JoinedMember)(nil), "CMsgDOTAChatChannelMemberUpdate.JoinedMember") + proto.RegisterType((*CMsgDOTARequestChatChannelList)(nil), "CMsgDOTARequestChatChannelList") + proto.RegisterType((*CMsgDOTARequestChatChannelListResponse)(nil), "CMsgDOTARequestChatChannelListResponse") + proto.RegisterType((*CMsgDOTARequestChatChannelListResponse_ChatChannel)(nil), "CMsgDOTARequestChatChannelListResponse.ChatChannel") + proto.RegisterType((*CMsgDOTAChatGetUserList)(nil), "CMsgDOTAChatGetUserList") + proto.RegisterType((*CMsgDOTAChatGetUserListResponse)(nil), "CMsgDOTAChatGetUserListResponse") + proto.RegisterType((*CMsgDOTAChatGetUserListResponse_Member)(nil), "CMsgDOTAChatGetUserListResponse.Member") + proto.RegisterType((*CMsgDOTAChatGetMemberCount)(nil), "CMsgDOTAChatGetMemberCount") + proto.RegisterType((*CMsgDOTAChatGetMemberCountResponse)(nil), "CMsgDOTAChatGetMemberCountResponse") + proto.RegisterType((*CMsgDOTAChatRegionsEnabled)(nil), "CMsgDOTAChatRegionsEnabled") + proto.RegisterType((*CMsgDOTAChatRegionsEnabled_Region)(nil), "CMsgDOTAChatRegionsEnabled.Region") + proto.RegisterType((*CMsgDOTAGuildSDO)(nil), "CMsgDOTAGuildSDO") + proto.RegisterType((*CMsgDOTAGuildSDO_Member)(nil), "CMsgDOTAGuildSDO.Member") + proto.RegisterType((*CMsgDOTAGuildSDO_Invitation)(nil), "CMsgDOTAGuildSDO.Invitation") + proto.RegisterType((*CMsgDOTAGuildAuditSDO)(nil), "CMsgDOTAGuildAuditSDO") + proto.RegisterType((*CMsgDOTAGuildAuditSDO_Entry)(nil), "CMsgDOTAGuildAuditSDO.Entry") + proto.RegisterType((*CMsgDOTAAccountGuildMembershipsSDO)(nil), "CMsgDOTAAccountGuildMembershipsSDO") + proto.RegisterType((*CMsgDOTAAccountGuildMembershipsSDO_Membership)(nil), "CMsgDOTAAccountGuildMembershipsSDO.Membership") + proto.RegisterType((*CMsgDOTAAccountGuildMembershipsSDO_Invitation)(nil), "CMsgDOTAAccountGuildMembershipsSDO.Invitation") + proto.RegisterType((*CMsgDOTAGuildCreateRequest)(nil), "CMsgDOTAGuildCreateRequest") + proto.RegisterType((*CMsgDOTAGuildCreateResponse)(nil), "CMsgDOTAGuildCreateResponse") + proto.RegisterType((*CMsgDOTAGuildSetAccountRoleRequest)(nil), "CMsgDOTAGuildSetAccountRoleRequest") + proto.RegisterType((*CMsgDOTAGuildSetAccountRoleResponse)(nil), "CMsgDOTAGuildSetAccountRoleResponse") + proto.RegisterType((*CMsgDOTAGuildInviteAccountRequest)(nil), "CMsgDOTAGuildInviteAccountRequest") + proto.RegisterType((*CMsgDOTAGuildInviteAccountResponse)(nil), "CMsgDOTAGuildInviteAccountResponse") + proto.RegisterType((*CMsgDOTAGuildCancelInviteRequest)(nil), "CMsgDOTAGuildCancelInviteRequest") + proto.RegisterType((*CMsgDOTAGuildCancelInviteResponse)(nil), "CMsgDOTAGuildCancelInviteResponse") + proto.RegisterType((*CMsgDOTAGuildUpdateDetailsRequest)(nil), "CMsgDOTAGuildUpdateDetailsRequest") + proto.RegisterType((*CMsgDOTAGuildUpdateDetailsResponse)(nil), "CMsgDOTAGuildUpdateDetailsResponse") + proto.RegisterType((*CMsgDOTAGCToGCUpdateOpenGuildPartyRequest)(nil), "CMsgDOTAGCToGCUpdateOpenGuildPartyRequest") + proto.RegisterType((*CMsgDOTAGCToGCUpdateOpenGuildPartyResponse)(nil), "CMsgDOTAGCToGCUpdateOpenGuildPartyResponse") + proto.RegisterType((*CMsgDOTAGCToGCDestroyOpenGuildPartyRequest)(nil), "CMsgDOTAGCToGCDestroyOpenGuildPartyRequest") + proto.RegisterType((*CMsgDOTAGCToGCDestroyOpenGuildPartyResponse)(nil), "CMsgDOTAGCToGCDestroyOpenGuildPartyResponse") + proto.RegisterType((*CMsgDOTAPartySetOpenGuildRequest)(nil), "CMsgDOTAPartySetOpenGuildRequest") + proto.RegisterType((*CMsgDOTAPartySetOpenGuildResponse)(nil), "CMsgDOTAPartySetOpenGuildResponse") + proto.RegisterType((*CMsgDOTAJoinOpenGuildPartyRequest)(nil), "CMsgDOTAJoinOpenGuildPartyRequest") + proto.RegisterType((*CMsgDOTAJoinOpenGuildPartyResponse)(nil), "CMsgDOTAJoinOpenGuildPartyResponse") + proto.RegisterType((*CMsgDOTAGuildOpenPartyRefresh)(nil), "CMsgDOTAGuildOpenPartyRefresh") + proto.RegisterType((*CMsgDOTAGuildOpenPartyRefresh_OpenParty)(nil), "CMsgDOTAGuildOpenPartyRefresh.OpenParty") + proto.RegisterType((*CMsgDOTARequestGuildData)(nil), "CMsgDOTARequestGuildData") + proto.RegisterType((*CMsgDOTAGuildInviteData)(nil), "CMsgDOTAGuildInviteData") + proto.RegisterType((*CMsgDOTAGuildUpdateMessage)(nil), "CMsgDOTAGuildUpdateMessage") + proto.RegisterType((*CMsgDOTAGuildEditLogoRequest)(nil), "CMsgDOTAGuildEditLogoRequest") + proto.RegisterType((*CMsgDOTAGuildEditLogoResponse)(nil), "CMsgDOTAGuildEditLogoResponse") + proto.RegisterType((*CMsgDOTAReportsRemainingRequest)(nil), "CMsgDOTAReportsRemainingRequest") + proto.RegisterType((*CMsgDOTAReportsRemainingResponse)(nil), "CMsgDOTAReportsRemainingResponse") + proto.RegisterType((*CMsgDOTASubmitPlayerReport)(nil), "CMsgDOTASubmitPlayerReport") + proto.RegisterType((*CMsgDOTASubmitPlayerReportResponse)(nil), "CMsgDOTASubmitPlayerReportResponse") + proto.RegisterType((*CMsgDOTAReportCountsRequest)(nil), "CMsgDOTAReportCountsRequest") + proto.RegisterType((*CMsgDOTAReportCountsResponse)(nil), "CMsgDOTAReportCountsResponse") + proto.RegisterType((*CMsgDOTAKickedFromMatchmakingQueue)(nil), "CMsgDOTAKickedFromMatchmakingQueue") + proto.RegisterType((*CMsgDOTARequestSaveGames)(nil), "CMsgDOTARequestSaveGames") + proto.RegisterType((*CMsgDOTARequestSaveGamesResponse)(nil), "CMsgDOTARequestSaveGamesResponse") + proto.RegisterType((*CMsgWatchGame)(nil), "CMsgWatchGame") + proto.RegisterType((*CMsgCancelWatchGame)(nil), "CMsgCancelWatchGame") + proto.RegisterType((*CMsgWatchGameResponse)(nil), "CMsgWatchGameResponse") + proto.RegisterType((*CMsgPartyLeaderWatchGamePrompt)(nil), "CMsgPartyLeaderWatchGamePrompt") + proto.RegisterType((*CMsgGCMatchDetailsRequest)(nil), "CMsgGCMatchDetailsRequest") + proto.RegisterType((*CMsgGCMatchDetailsResponse)(nil), "CMsgGCMatchDetailsResponse") + proto.RegisterType((*CMsgServerToGCMatchDetailsRequest)(nil), "CMsgServerToGCMatchDetailsRequest") + proto.RegisterType((*CMsgGCToServerMatchDetailsResponse)(nil), "CMsgGCToServerMatchDetailsResponse") + proto.RegisterType((*CMsgDOTAProfileRequest)(nil), "CMsgDOTAProfileRequest") + proto.RegisterType((*CMsgDOTAProfileResponse)(nil), "CMsgDOTAProfileResponse") + proto.RegisterType((*CMsgDOTAProfileResponse_PlayedHero)(nil), "CMsgDOTAProfileResponse.PlayedHero") + proto.RegisterType((*CMsgDOTAProfileResponse_ShowcaseHero)(nil), "CMsgDOTAProfileResponse.ShowcaseHero") + proto.RegisterType((*CMsgDOTAProfileResponse_LeaguePass)(nil), "CMsgDOTAProfileResponse.LeaguePass") + proto.RegisterType((*CMsgDOTAProfileResponse_EventTicket)(nil), "CMsgDOTAProfileResponse.EventTicket") + proto.RegisterType((*CMsgDOTAProfileResponse_FeaturedItem)(nil), "CMsgDOTAProfileResponse.FeaturedItem") + proto.RegisterType((*CMsgDOTAProfileTickets)(nil), "CMsgDOTAProfileTickets") + proto.RegisterType((*CMsgDOTAProfileTickets_LeaguePass)(nil), "CMsgDOTAProfileTickets.LeaguePass") + proto.RegisterType((*CMsgDOTAProfileTickets_EventTicket)(nil), "CMsgDOTAProfileTickets.EventTicket") + proto.RegisterType((*CMsgClientToGCGetProfileTickets)(nil), "CMsgClientToGCGetProfileTickets") + proto.RegisterType((*CMsgGCSteamProfileRequest)(nil), "CMsgGCSteamProfileRequest") + proto.RegisterType((*CMsgGCSteamProfileRequestResponse)(nil), "CMsgGCSteamProfileRequestResponse") + proto.RegisterType((*CMsgDOTAClearNotifySuccessfulReport)(nil), "CMsgDOTAClearNotifySuccessfulReport") + proto.RegisterType((*CMsgDOTAWelcome)(nil), "CMsgDOTAWelcome") + proto.RegisterType((*CMsgDOTAWelcome_LocalizationDigest)(nil), "CMsgDOTAWelcome.LocalizationDigest") + proto.RegisterType((*CMsgDOTAWelcome_CExtraMsg)(nil), "CMsgDOTAWelcome.CExtraMsg") + proto.RegisterType((*CSODOTAGameHeroFavorites)(nil), "CSODOTAGameHeroFavorites") + proto.RegisterType((*CMsgDOTAHeroFavoritesAdd)(nil), "CMsgDOTAHeroFavoritesAdd") + proto.RegisterType((*CMsgDOTAHeroFavoritesRemove)(nil), "CMsgDOTAHeroFavoritesRemove") + proto.RegisterType((*CMsgSetShowcaseHero)(nil), "CMsgSetShowcaseHero") + proto.RegisterType((*CMsgSetFeaturedItems)(nil), "CMsgSetFeaturedItems") + proto.RegisterType((*CMsgDOTAFeaturedItems)(nil), "CMsgDOTAFeaturedItems") + proto.RegisterType((*CMsgRequestLeagueInfo)(nil), "CMsgRequestLeagueInfo") + proto.RegisterType((*CDynamicLeagueData)(nil), "CDynamicLeagueData") + proto.RegisterType((*CStaticLeagueData)(nil), "CStaticLeagueData") + proto.RegisterType((*CLeagueData)(nil), "CLeagueData") + proto.RegisterType((*CMsgResponseLeagueInfo)(nil), "CMsgResponseLeagueInfo") + proto.RegisterType((*CMsgDOTAMatchVotes)(nil), "CMsgDOTAMatchVotes") + proto.RegisterType((*CMsgDOTAMatchVotes_PlayerVote)(nil), "CMsgDOTAMatchVotes.PlayerVote") + proto.RegisterType((*CMsgCastMatchVote)(nil), "CMsgCastMatchVote") + proto.RegisterType((*CMsgRetrieveMatchVote)(nil), "CMsgRetrieveMatchVote") + proto.RegisterType((*CMsgMatchVoteResponse)(nil), "CMsgMatchVoteResponse") + proto.RegisterType((*CMsgDOTAHallOfFame)(nil), "CMsgDOTAHallOfFame") + proto.RegisterType((*CMsgDOTAHallOfFame_FeaturedPlayer)(nil), "CMsgDOTAHallOfFame.FeaturedPlayer") + proto.RegisterType((*CMsgDOTAHallOfFame_FeaturedFarmer)(nil), "CMsgDOTAHallOfFame.FeaturedFarmer") + proto.RegisterType((*CMsgDOTAHallOfFameRequest)(nil), "CMsgDOTAHallOfFameRequest") + proto.RegisterType((*CMsgDOTAHallOfFameResponse)(nil), "CMsgDOTAHallOfFameResponse") + proto.RegisterType((*CMsgDOTAHalloweenHighScoreRequest)(nil), "CMsgDOTAHalloweenHighScoreRequest") + proto.RegisterType((*CMsgDOTAHalloweenHighScoreResponse)(nil), "CMsgDOTAHalloweenHighScoreResponse") + proto.RegisterType((*CMsgDOTAStorePromoPagesRequest)(nil), "CMsgDOTAStorePromoPagesRequest") + proto.RegisterType((*CMsgDOTAStorePromoPagesResponse)(nil), "CMsgDOTAStorePromoPagesResponse") + proto.RegisterType((*CMsgDOTAStorePromoPagesResponse_PromoPage)(nil), "CMsgDOTAStorePromoPagesResponse.PromoPage") + proto.RegisterType((*CMsgLeagueScheduleBlockTeamInfo)(nil), "CMsgLeagueScheduleBlockTeamInfo") + proto.RegisterType((*CMsgLeagueScheduleBlock)(nil), "CMsgLeagueScheduleBlock") + proto.RegisterType((*CMsgDOTALeague)(nil), "CMsgDOTALeague") + proto.RegisterType((*CMsgDOTALeagueScheduleRequest)(nil), "CMsgDOTALeagueScheduleRequest") + proto.RegisterType((*CMsgDOTALeagueScheduleResponse)(nil), "CMsgDOTALeagueScheduleResponse") + proto.RegisterType((*CMsgDOTALeagueScheduleEdit)(nil), "CMsgDOTALeagueScheduleEdit") + proto.RegisterType((*CMsgDOTALeagueScheduleEditResponse)(nil), "CMsgDOTALeagueScheduleEditResponse") + proto.RegisterType((*CMsgDOTALeaguesInMonthRequest)(nil), "CMsgDOTALeaguesInMonthRequest") + proto.RegisterType((*CMsgDOTALeaguesInMonthResponse)(nil), "CMsgDOTALeaguesInMonthResponse") + proto.RegisterType((*CMsgMatchGroupServerStatus)(nil), "CMsgMatchGroupServerStatus") + proto.RegisterType((*CMsgMatchmakingGroupServerSample)(nil), "CMsgMatchmakingGroupServerSample") + proto.RegisterType((*CMsgDOTAMatchmakingStatsRequest)(nil), "CMsgDOTAMatchmakingStatsRequest") + proto.RegisterType((*CMsgDOTAMatchmakingStatsResponse)(nil), "CMsgDOTAMatchmakingStatsResponse") + proto.RegisterType((*CMsgDOTASetMatchHistoryAccess)(nil), "CMsgDOTASetMatchHistoryAccess") + proto.RegisterType((*CMsgDOTASetMatchHistoryAccessResponse)(nil), "CMsgDOTASetMatchHistoryAccessResponse") + proto.RegisterType((*CMsgDOTANotifyAccountFlagsChange)(nil), "CMsgDOTANotifyAccountFlagsChange") + proto.RegisterType((*CMsgDOTASetProfilePrivacy)(nil), "CMsgDOTASetProfilePrivacy") + proto.RegisterType((*CMsgDOTASetProfilePrivacyResponse)(nil), "CMsgDOTASetProfilePrivacyResponse") + proto.RegisterType((*CMsgUpgradeLeagueItem)(nil), "CMsgUpgradeLeagueItem") + proto.RegisterType((*CMsgUpgradeLeagueItemResponse)(nil), "CMsgUpgradeLeagueItemResponse") + proto.RegisterType((*CMsgGCWatchDownloadedReplay)(nil), "CMsgGCWatchDownloadedReplay") + proto.RegisterType((*CMsgSetMapLocationState)(nil), "CMsgSetMapLocationState") + proto.RegisterType((*CMsgSetMapLocationStateResponse)(nil), "CMsgSetMapLocationStateResponse") + proto.RegisterType((*CMsgResetMapLocations)(nil), "CMsgResetMapLocations") + proto.RegisterType((*CMsgResetMapLocationsResponse)(nil), "CMsgResetMapLocationsResponse") + proto.RegisterType((*CMsgRefreshPartnerAccountLink)(nil), "CMsgRefreshPartnerAccountLink") + proto.RegisterType((*CMsgClientsRejoinChatChannels)(nil), "CMsgClientsRejoinChatChannels") + proto.RegisterType((*CMsgDOTASendFriendRecruits)(nil), "CMsgDOTASendFriendRecruits") + proto.RegisterType((*CMsgDOTAFriendRecruitsRequest)(nil), "CMsgDOTAFriendRecruitsRequest") + proto.RegisterType((*CMsgDOTAFriendRecruitsResponse)(nil), "CMsgDOTAFriendRecruitsResponse") + proto.RegisterType((*CMsgDOTAFriendRecruitsResponse_FriendRecruitStatus)(nil), "CMsgDOTAFriendRecruitsResponse.FriendRecruitStatus") + proto.RegisterType((*CMsgDOTAFriendRecruitInviteAcceptDecline)(nil), "CMsgDOTAFriendRecruitInviteAcceptDecline") + proto.RegisterType((*CMsgRequestLeaguePrizePool)(nil), "CMsgRequestLeaguePrizePool") + proto.RegisterType((*CMsgRequestLeaguePrizePoolResponse)(nil), "CMsgRequestLeaguePrizePoolResponse") + proto.RegisterType((*CMsgGCGetHeroStandings)(nil), "CMsgGCGetHeroStandings") + proto.RegisterType((*CMsgGCGetHeroStandingsResponse)(nil), "CMsgGCGetHeroStandingsResponse") + proto.RegisterType((*CMsgGCGetHeroStandingsResponse_Hero)(nil), "CMsgGCGetHeroStandingsResponse.Hero") + proto.RegisterType((*CMsgGCItemEditorReservationsRequest)(nil), "CMsgGCItemEditorReservationsRequest") + proto.RegisterType((*CMsgGCItemEditorReservation)(nil), "CMsgGCItemEditorReservation") + proto.RegisterType((*CMsgGCItemEditorReservationsResponse)(nil), "CMsgGCItemEditorReservationsResponse") + proto.RegisterType((*CMsgGCItemEditorReserveItemDef)(nil), "CMsgGCItemEditorReserveItemDef") + proto.RegisterType((*CMsgGCItemEditorReserveItemDefResponse)(nil), "CMsgGCItemEditorReserveItemDefResponse") + proto.RegisterType((*CMsgGCItemEditorReleaseReservation)(nil), "CMsgGCItemEditorReleaseReservation") + proto.RegisterType((*CMsgGCItemEditorReleaseReservationResponse)(nil), "CMsgGCItemEditorReleaseReservationResponse") + proto.RegisterType((*CMsgGCItemEditorRequestLeagueInfo)(nil), "CMsgGCItemEditorRequestLeagueInfo") + proto.RegisterType((*CMsgGCItemEditorLeagueInfoResponse)(nil), "CMsgGCItemEditorLeagueInfoResponse") + proto.RegisterType((*CMsgDOTARewardTutorialPrizes)(nil), "CMsgDOTARewardTutorialPrizes") + proto.RegisterType((*CMsgDOTALastHitChallengeHighScorePost)(nil), "CMsgDOTALastHitChallengeHighScorePost") + proto.RegisterType((*CMsgDOTALastHitChallengeHighScoreRequest)(nil), "CMsgDOTALastHitChallengeHighScoreRequest") + proto.RegisterType((*CMsgDOTALastHitChallengeHighScoreResponse)(nil), "CMsgDOTALastHitChallengeHighScoreResponse") + proto.RegisterType((*CMsgFlipLobbyTeams)(nil), "CMsgFlipLobbyTeams") + proto.RegisterType((*CMsgPresentedClientTerminateDlg)(nil), "CMsgPresentedClientTerminateDlg") + proto.RegisterType((*CMsgGCLobbyUpdateBroadcastChannelInfo)(nil), "CMsgGCLobbyUpdateBroadcastChannelInfo") + proto.RegisterType((*CMsgDOTARedeemEventPrize)(nil), "CMsgDOTARedeemEventPrize") + proto.RegisterType((*CMsgDOTARedeemEventPrizeResponse)(nil), "CMsgDOTARedeemEventPrizeResponse") + proto.RegisterType((*CMsgDOTAGetEventPoints)(nil), "CMsgDOTAGetEventPoints") + proto.RegisterType((*CMsgDOTAGetEventPointsResponse)(nil), "CMsgDOTAGetEventPointsResponse") + proto.RegisterType((*CMsgDOTAGetEventPointsResponse_Action)(nil), "CMsgDOTAGetEventPointsResponse.Action") + proto.RegisterType((*CMsgDOTALiveLeagueGameUpdate)(nil), "CMsgDOTALiveLeagueGameUpdate") + proto.RegisterType((*CMsgDOTACompendiumSelection)(nil), "CMsgDOTACompendiumSelection") + proto.RegisterType((*CMsgDOTACompendiumSelectionResponse)(nil), "CMsgDOTACompendiumSelectionResponse") + proto.RegisterType((*CMsgDOTACompendiumData)(nil), "CMsgDOTACompendiumData") + proto.RegisterType((*CMsgDOTACompendiumDataRequest)(nil), "CMsgDOTACompendiumDataRequest") + proto.RegisterType((*CMsgDOTACompendiumDataResponse)(nil), "CMsgDOTACompendiumDataResponse") + proto.RegisterType((*CMsgDOTAGetPlayerMatchHistory)(nil), "CMsgDOTAGetPlayerMatchHistory") + proto.RegisterType((*CMsgDOTAGetPlayerMatchHistoryResponse)(nil), "CMsgDOTAGetPlayerMatchHistoryResponse") + proto.RegisterType((*CMsgDOTAGetPlayerMatchHistoryResponse_Match)(nil), "CMsgDOTAGetPlayerMatchHistoryResponse.Match") + proto.RegisterType((*CMsgDOTAStartDailyHeroChallenge)(nil), "CMsgDOTAStartDailyHeroChallenge") + proto.RegisterType((*CMsgGCNotificationsRequest)(nil), "CMsgGCNotificationsRequest") + proto.RegisterType((*CMsgGCNotificationsResponse)(nil), "CMsgGCNotificationsResponse") + proto.RegisterType((*CMsgGCNotificationsResponse_Notification)(nil), "CMsgGCNotificationsResponse.Notification") + proto.RegisterType((*CMsgGCNotificationsMarkReadRequest)(nil), "CMsgGCNotificationsMarkReadRequest") + proto.RegisterType((*CMsgClientToGCMarkNotificationListRead)(nil), "CMsgClientToGCMarkNotificationListRead") + proto.RegisterType((*CMsgGCLeagueAdminState)(nil), "CMsgGCLeagueAdminState") + proto.RegisterType((*CMsgGCLeagueAdminState_PrivateLeagueKeys)(nil), "CMsgGCLeagueAdminState.PrivateLeagueKeys") + proto.RegisterType((*CMsgGCPlayerInfoRequest)(nil), "CMsgGCPlayerInfoRequest") + proto.RegisterType((*CMsgGCPlayerInfoSubmit)(nil), "CMsgGCPlayerInfoSubmit") + proto.RegisterType((*CMsgGCPlayerInfoSubmitResponse)(nil), "CMsgGCPlayerInfoSubmitResponse") + proto.RegisterType((*CMsgSerializedSOCache)(nil), "CMsgSerializedSOCache") + proto.RegisterType((*CMsgSerializedSOCache_TypeCache)(nil), "CMsgSerializedSOCache.TypeCache") + proto.RegisterType((*CMsgSerializedSOCache_Cache)(nil), "CMsgSerializedSOCache.Cache") + proto.RegisterType((*CMsgSerializedSOCache_Cache_Version)(nil), "CMsgSerializedSOCache.Cache.Version") + proto.RegisterType((*CMsgRequestWeekendTourneySchedule)(nil), "CMsgRequestWeekendTourneySchedule") + proto.RegisterType((*CMsgWeekendTourneySchedule)(nil), "CMsgWeekendTourneySchedule") + proto.RegisterType((*CMsgWeekendTourneySchedule_Division)(nil), "CMsgWeekendTourneySchedule.Division") + proto.RegisterType((*CMsgClientProvideSurveyResult)(nil), "CMsgClientProvideSurveyResult") + proto.RegisterType((*CMsgClientProvideSurveyResult_Response)(nil), "CMsgClientProvideSurveyResult.Response") + proto.RegisterType((*CMsgDOTAEmoticonAccessSDO)(nil), "CMsgDOTAEmoticonAccessSDO") + proto.RegisterType((*CMsgClientToGCEmoticonDataRequest)(nil), "CMsgClientToGCEmoticonDataRequest") + proto.RegisterType((*CMsgGCToClientEmoticonData)(nil), "CMsgGCToClientEmoticonData") + proto.RegisterType((*CMsgClientToGCTrackDialogResult)(nil), "CMsgClientToGCTrackDialogResult") + proto.RegisterType((*CMsgGCToClientTournamentItemDrop)(nil), "CMsgGCToClientTournamentItemDrop") + proto.RegisterType((*CMsgClientToGCSetAdditionalEquips)(nil), "CMsgClientToGCSetAdditionalEquips") + proto.RegisterType((*CMsgClientToGCSetAdditionalEquipsResponse)(nil), "CMsgClientToGCSetAdditionalEquipsResponse") + proto.RegisterType((*CMsgClientToGCGetAdditionalEquips)(nil), "CMsgClientToGCGetAdditionalEquips") + proto.RegisterType((*CMsgClientToGCGetAdditionalEquipsResponse)(nil), "CMsgClientToGCGetAdditionalEquipsResponse") + proto.RegisterType((*CMsgClientToGCGetAllHeroOrder)(nil), "CMsgClientToGCGetAllHeroOrder") + proto.RegisterType((*CMsgClientToGCGetAllHeroOrderResponse)(nil), "CMsgClientToGCGetAllHeroOrderResponse") + proto.RegisterType((*CMsgClientToGCGetAllHeroProgress)(nil), "CMsgClientToGCGetAllHeroProgress") + proto.RegisterType((*CMsgClientToGCGetAllHeroProgressResponse)(nil), "CMsgClientToGCGetAllHeroProgressResponse") + proto.RegisterType((*CMsgClientToGCGetTrophyList)(nil), "CMsgClientToGCGetTrophyList") + proto.RegisterType((*CMsgClientToGCGetTrophyListResponse)(nil), "CMsgClientToGCGetTrophyListResponse") + proto.RegisterType((*CMsgClientToGCGetTrophyListResponse_Trophy)(nil), "CMsgClientToGCGetTrophyListResponse.Trophy") + proto.RegisterType((*CMsgGCToClientTrophyAwarded)(nil), "CMsgGCToClientTrophyAwarded") + proto.RegisterType((*CMsgClientToGCGetProfileCard)(nil), "CMsgClientToGCGetProfileCard") + proto.RegisterType((*CMsgClientToGCSetProfileCardSlots)(nil), "CMsgClientToGCSetProfileCardSlots") + proto.RegisterType((*CMsgClientToGCSetProfileCardSlots_CardSlot)(nil), "CMsgClientToGCSetProfileCardSlots.CardSlot") + proto.RegisterType((*CMsgClientToGCGetProfileCardStats)(nil), "CMsgClientToGCGetProfileCardStats") + proto.RegisterType((*CMsgClientToGCCreateHeroStatue)(nil), "CMsgClientToGCCreateHeroStatue") + proto.RegisterType((*CMsgClientToGCCreateTeamShowcase)(nil), "CMsgClientToGCCreateTeamShowcase") + proto.RegisterType((*CMsgGCToClientHeroStatueCreateResult)(nil), "CMsgGCToClientHeroStatueCreateResult") + proto.RegisterType((*CMsgGCToClientTeamShowcaseCreateResult)(nil), "CMsgGCToClientTeamShowcaseCreateResult") + proto.RegisterType((*CMsgClientToGCRecordCompendiumStats)(nil), "CMsgClientToGCRecordCompendiumStats") + proto.RegisterType((*CMsgGCToClientEventStatusChanged)(nil), "CMsgGCToClientEventStatusChanged") + proto.RegisterType((*CMsgClientToGCPlayerStatsRequest)(nil), "CMsgClientToGCPlayerStatsRequest") + proto.RegisterType((*CMsgGCToClientPlayerStatsResponse)(nil), "CMsgGCToClientPlayerStatsResponse") + proto.RegisterType((*CMsgClientToGCCustomGamePlayerCountRequest)(nil), "CMsgClientToGCCustomGamePlayerCountRequest") + proto.RegisterType((*CMsgGCToClientCustomGamePlayerCountResponse)(nil), "CMsgGCToClientCustomGamePlayerCountResponse") + proto.RegisterType((*CMsgClientToGCCustomGamesFriendsPlayedRequest)(nil), "CMsgClientToGCCustomGamesFriendsPlayedRequest") + proto.RegisterType((*CMsgGCToClientCustomGamesFriendsPlayedResponse)(nil), "CMsgGCToClientCustomGamesFriendsPlayedResponse") + proto.RegisterType((*CMsgGCToClientCustomGamesFriendsPlayedResponse_CustomGame)(nil), "CMsgGCToClientCustomGamesFriendsPlayedResponse.CustomGame") + proto.RegisterType((*CMsgClientToGCSocialFeedPostCommentRequest)(nil), "CMsgClientToGCSocialFeedPostCommentRequest") + proto.RegisterType((*CMsgGCToClientSocialFeedPostCommentResponse)(nil), "CMsgGCToClientSocialFeedPostCommentResponse") + proto.RegisterType((*CMsgClientToGCSocialFeedPostMessageRequest)(nil), "CMsgClientToGCSocialFeedPostMessageRequest") + proto.RegisterType((*CMsgGCToClientSocialFeedPostMessageResponse)(nil), "CMsgGCToClientSocialFeedPostMessageResponse") + proto.RegisterType((*CMsgClientToGCFriendsPlayedCustomGameRequest)(nil), "CMsgClientToGCFriendsPlayedCustomGameRequest") + proto.RegisterType((*CMsgGCToClientFriendsPlayedCustomGameResponse)(nil), "CMsgGCToClientFriendsPlayedCustomGameResponse") + proto.RegisterType((*CMsgClientToGCFeaturedHeroesRequest)(nil), "CMsgClientToGCFeaturedHeroesRequest") + proto.RegisterType((*CMsgGCToClientFeaturedHeroesResponse)(nil), "CMsgGCToClientFeaturedHeroesResponse") + proto.RegisterType((*CMsgGCToClientFeaturedHeroesResponse_DataField)(nil), "CMsgGCToClientFeaturedHeroesResponse.DataField") + proto.RegisterType((*CMsgGCToClientFeaturedHeroesResponse_FeaturedHero)(nil), "CMsgGCToClientFeaturedHeroesResponse.FeaturedHero") + proto.RegisterType((*CMsgGCToClientFeaturedHeroesResponse_Category)(nil), "CMsgGCToClientFeaturedHeroesResponse.Category") + proto.RegisterType((*CMsgClientToGCSocialMatchPostCommentRequest)(nil), "CMsgClientToGCSocialMatchPostCommentRequest") + proto.RegisterType((*CMsgGCToClientSocialMatchPostCommentResponse)(nil), "CMsgGCToClientSocialMatchPostCommentResponse") + proto.RegisterType((*CMsgClientToGCSocialMatchDetailsRequest)(nil), "CMsgClientToGCSocialMatchDetailsRequest") + proto.RegisterType((*CMsgGCToClientSocialMatchDetailsResponse)(nil), "CMsgGCToClientSocialMatchDetailsResponse") + proto.RegisterType((*CMsgGCToClientSocialMatchDetailsResponse_Comment)(nil), "CMsgGCToClientSocialMatchDetailsResponse.Comment") + proto.RegisterType((*CMsgDOTAPartyMemberSetCoach)(nil), "CMsgDOTAPartyMemberSetCoach") + proto.RegisterType((*CMsgDOTASetGroupLeader)(nil), "CMsgDOTASetGroupLeader") + proto.RegisterType((*CMsgDOTACancelGroupInvites)(nil), "CMsgDOTACancelGroupInvites") + proto.RegisterType((*CMsgDOTASetGroupOpenStatus)(nil), "CMsgDOTASetGroupOpenStatus") + proto.RegisterType((*CMsgDOTAGroupMergeInvite)(nil), "CMsgDOTAGroupMergeInvite") + proto.RegisterType((*CMsgDOTAGroupMergeResponse)(nil), "CMsgDOTAGroupMergeResponse") + proto.RegisterType((*CMsgDOTAGroupMergeReply)(nil), "CMsgDOTAGroupMergeReply") + proto.RegisterType((*CMsgDOTAPartyRichPresence)(nil), "CMsgDOTAPartyRichPresence") + proto.RegisterType((*CMsgDOTAPartyRichPresence_Member)(nil), "CMsgDOTAPartyRichPresence.Member") + proto.RegisterType((*CMsgDOTALobbyRichPresence)(nil), "CMsgDOTALobbyRichPresence") + proto.RegisterType((*CMsgDOTACustomGameListenServerStartedLoading)(nil), "CMsgDOTACustomGameListenServerStartedLoading") + proto.RegisterType((*CMsgDOTACustomGameClientFinishedLoading)(nil), "CMsgDOTACustomGameClientFinishedLoading") + proto.RegisterType((*CMsgClientToGCGetLeagueSeries)(nil), "CMsgClientToGCGetLeagueSeries") + proto.RegisterType((*CMsgClientToGCGetLeagueSeriesResponse)(nil), "CMsgClientToGCGetLeagueSeriesResponse") + proto.RegisterType((*CMsgClientToGCGetLeagueSeriesResponse_Series)(nil), "CMsgClientToGCGetLeagueSeriesResponse.Series") + proto.RegisterType((*CMsgClientToGCGetLeagueSeriesResponse_Series_Team)(nil), "CMsgClientToGCGetLeagueSeriesResponse.Series.Team") + proto.RegisterType((*CMsgClientToGCApplyGemCombiner)(nil), "CMsgClientToGCApplyGemCombiner") + proto.RegisterType((*CDummyUnbreakMessage)(nil), "CDummyUnbreakMessage") + proto.RegisterType((*CMsgClientToGCCreateStaticRecipe)(nil), "CMsgClientToGCCreateStaticRecipe") + proto.RegisterType((*CMsgClientToGCCreateStaticRecipe_Item)(nil), "CMsgClientToGCCreateStaticRecipe.Item") + proto.RegisterType((*CMsgClientToGCCreateStaticRecipeResponse)(nil), "CMsgClientToGCCreateStaticRecipeResponse") + proto.RegisterType((*CDOTAReplayDownloadInfo)(nil), "CDOTAReplayDownloadInfo") + proto.RegisterType((*CDOTAReplayDownloadInfo_Highlight)(nil), "CDOTAReplayDownloadInfo.Highlight") + proto.RegisterType((*CDOTABroadcasterInfo)(nil), "CDOTABroadcasterInfo") + proto.RegisterType((*CMsgClientToGCH264Unsupported)(nil), "CMsgClientToGCH264Unsupported") + proto.RegisterType((*CMsgClientToGCRequestH264Support)(nil), "CMsgClientToGCRequestH264Support") + proto.RegisterType((*CMsgClientToGCGetQuestProgress)(nil), "CMsgClientToGCGetQuestProgress") + proto.RegisterType((*CMsgClientToGCGetQuestProgressResponse)(nil), "CMsgClientToGCGetQuestProgressResponse") + proto.RegisterType((*CMsgClientToGCGetQuestProgressResponse_Challenge)(nil), "CMsgClientToGCGetQuestProgressResponse.Challenge") + proto.RegisterType((*CMsgClientToGCGetQuestProgressResponse_Quest)(nil), "CMsgClientToGCGetQuestProgressResponse.Quest") + proto.RegisterType((*CMsgGCToClientMatchSignedOut)(nil), "CMsgGCToClientMatchSignedOut") + proto.RegisterType((*CMsgGCGetHeroStatsHistory)(nil), "CMsgGCGetHeroStatsHistory") + proto.RegisterType((*CMsgGCGetHeroStatsHistoryResponse)(nil), "CMsgGCGetHeroStatsHistoryResponse") + proto.RegisterType((*CMsgClientToGCPrivateChatInvite)(nil), "CMsgClientToGCPrivateChatInvite") + proto.RegisterType((*CMsgClientToGCPrivateChatKick)(nil), "CMsgClientToGCPrivateChatKick") + proto.RegisterType((*CMsgClientToGCPrivateChatPromote)(nil), "CMsgClientToGCPrivateChatPromote") + proto.RegisterType((*CMsgClientToGCPrivateChatDemote)(nil), "CMsgClientToGCPrivateChatDemote") + proto.RegisterType((*CMsgGCToClientPrivateChatResponse)(nil), "CMsgGCToClientPrivateChatResponse") + proto.RegisterType((*CMsgClientToGCPrivateChatInfoRequest)(nil), "CMsgClientToGCPrivateChatInfoRequest") + proto.RegisterType((*CMsgGCToClientPrivateChatInfoResponse)(nil), "CMsgGCToClientPrivateChatInfoResponse") + proto.RegisterType((*CMsgGCToClientPrivateChatInfoResponse_Member)(nil), "CMsgGCToClientPrivateChatInfoResponse.Member") + proto.RegisterType((*CMsgPlayerBehaviorReport)(nil), "CMsgPlayerBehaviorReport") + proto.RegisterEnum("EMatchGroupServerStatus", EMatchGroupServerStatus_name, EMatchGroupServerStatus_value) + proto.RegisterEnum("DOTA_WatchReplayType", DOTA_WatchReplayType_name, DOTA_WatchReplayType_value) + proto.RegisterEnum("EItemEditorReservationResult", EItemEditorReservationResult_name, EItemEditorReservationResult_value) + proto.RegisterEnum("EProfileCardSlotType", EProfileCardSlotType_name, EProfileCardSlotType_value) + proto.RegisterEnum("EFeaturedHeroTextField", EFeaturedHeroTextField_name, EFeaturedHeroTextField_value) + proto.RegisterEnum("EFeaturedHeroDataType", EFeaturedHeroDataType_name, EFeaturedHeroDataType_value) + proto.RegisterEnum("EDOTAGroupMergeResult", EDOTAGroupMergeResult_name, EDOTAGroupMergeResult_value) + proto.RegisterEnum("CMsgDOTAMatch_ReplayState", CMsgDOTAMatch_ReplayState_name, CMsgDOTAMatch_ReplayState_value) + proto.RegisterEnum("CMsgDOTARequestMatches_SkillLevel", CMsgDOTARequestMatches_SkillLevel_name, CMsgDOTARequestMatches_SkillLevel_value) + proto.RegisterEnum("CMsgDOTAPopup_PopupID", CMsgDOTAPopup_PopupID_name, CMsgDOTAPopup_PopupID_value) + proto.RegisterEnum("CMsgDOTACreateTeamResponse_Result", CMsgDOTACreateTeamResponse_Result_name, CMsgDOTACreateTeamResponse_Result_value) + proto.RegisterEnum("CMsgDOTAEditTeamLogoResponse_Result", CMsgDOTAEditTeamLogoResponse_Result_name, CMsgDOTAEditTeamLogoResponse_Result_value) + proto.RegisterEnum("CMsgDOTAEditTeamDetailsResponse_Result", CMsgDOTAEditTeamDetailsResponse_Result_name, CMsgDOTAEditTeamDetailsResponse_Result_value) + proto.RegisterEnum("CMsgDOTADisbandTeamResponse_Result", CMsgDOTADisbandTeamResponse_Result_name, CMsgDOTADisbandTeamResponse_Result_value) + proto.RegisterEnum("CMsgDOTARequestTeamDataResponse_Result", CMsgDOTARequestTeamDataResponse_Result_name, CMsgDOTARequestTeamDataResponse_Result_value) + proto.RegisterEnum("CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result", CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result_name, CMsgDOTATeamInvite_GCImmediateResponseToInviter_Result_value) + proto.RegisterEnum("CMsgDOTATeamInvite_InviteeResponseToGC_Result", CMsgDOTATeamInvite_InviteeResponseToGC_Result_name, CMsgDOTATeamInvite_InviteeResponseToGC_Result_value) + proto.RegisterEnum("CMsgDOTATeamInvite_GCResponseToInviter_Result", CMsgDOTATeamInvite_GCResponseToInviter_Result_name, CMsgDOTATeamInvite_GCResponseToInviter_Result_value) + proto.RegisterEnum("CMsgDOTATeamInvite_GCResponseToInvitee_Result", CMsgDOTATeamInvite_GCResponseToInvitee_Result_name, CMsgDOTATeamInvite_GCResponseToInvitee_Result_value) + proto.RegisterEnum("CMsgDOTAKickTeamMemberResponse_Result", CMsgDOTAKickTeamMemberResponse_Result_name, CMsgDOTAKickTeamMemberResponse_Result_value) + proto.RegisterEnum("CMsgDOTATransferTeamAdminResponse_Result", CMsgDOTATransferTeamAdminResponse_Result_name, CMsgDOTATransferTeamAdminResponse_Result_value) + proto.RegisterEnum("CMsgDOTALeaveTeamResponse_Result", CMsgDOTALeaveTeamResponse_Result_name, CMsgDOTALeaveTeamResponse_Result_value) + proto.RegisterEnum("CMsgDOTAJoinChatChannelResponse_Result", CMsgDOTAJoinChatChannelResponse_Result_name, CMsgDOTAJoinChatChannelResponse_Result_value) + proto.RegisterEnum("CMsgDOTAGuildCreateResponse_EError", CMsgDOTAGuildCreateResponse_EError_name, CMsgDOTAGuildCreateResponse_EError_value) + proto.RegisterEnum("CMsgDOTAGuildSetAccountRoleResponse_EResult", CMsgDOTAGuildSetAccountRoleResponse_EResult_name, CMsgDOTAGuildSetAccountRoleResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAGuildInviteAccountResponse_EResult", CMsgDOTAGuildInviteAccountResponse_EResult_name, CMsgDOTAGuildInviteAccountResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAGuildCancelInviteResponse_EResult", CMsgDOTAGuildCancelInviteResponse_EResult_name, CMsgDOTAGuildCancelInviteResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAGuildUpdateDetailsResponse_EResult", CMsgDOTAGuildUpdateDetailsResponse_EResult_name, CMsgDOTAGuildUpdateDetailsResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAPartySetOpenGuildResponse_EResult", CMsgDOTAPartySetOpenGuildResponse_EResult_name, CMsgDOTAPartySetOpenGuildResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAJoinOpenGuildPartyResponse_EResult", CMsgDOTAJoinOpenGuildPartyResponse_EResult_name, CMsgDOTAJoinOpenGuildPartyResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAGuildEditLogoResponse_EResult", CMsgDOTAGuildEditLogoResponse_EResult_name, CMsgDOTAGuildEditLogoResponse_EResult_value) + proto.RegisterEnum("CMsgWatchGameResponse_WatchGameResult", CMsgWatchGameResponse_WatchGameResult_name, CMsgWatchGameResponse_WatchGameResult_value) + proto.RegisterEnum("CMsgDOTAFriendRecruitsResponse_EResult", CMsgDOTAFriendRecruitsResponse_EResult_name, CMsgDOTAFriendRecruitsResponse_EResult_value) + proto.RegisterEnum("CMsgDOTARedeemEventPrizeResponse_ResultCode", CMsgDOTARedeemEventPrizeResponse_ResultCode_name, CMsgDOTARedeemEventPrizeResponse_ResultCode_value) + proto.RegisterEnum("CMsgGCNotificationsResponse_EResult", CMsgGCNotificationsResponse_EResult_name, CMsgGCNotificationsResponse_EResult_value) + proto.RegisterEnum("CMsgGCPlayerInfoSubmitResponse_EResult", CMsgGCPlayerInfoSubmitResponse_EResult_name, CMsgGCPlayerInfoSubmitResponse_EResult_value) + proto.RegisterEnum("CMsgClientToGCCreateStaticRecipeResponse_EResponse", CMsgClientToGCCreateStaticRecipeResponse_EResponse_name, CMsgClientToGCCreateStaticRecipeResponse_EResponse_value) + proto.RegisterEnum("CMsgGCToClientPrivateChatResponse_Result", CMsgGCToClientPrivateChatResponse_Result_name, CMsgGCToClientPrivateChatResponse_Result_value) +} + +var dota_client_fileDescriptor0 = []byte{ + // 17332 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0xbd, 0x7b, 0x8c, 0x5b, 0x57, + 0x7a, 0x38, 0xb6, 0x7c, 0xcc, 0xeb, 0xcc, 0x43, 0x14, 0xf5, 0x1a, 0xd1, 0xb2, 0x24, 0x5f, 0xcb, + 0x96, 0x25, 0x5b, 0xb4, 0x35, 0xf2, 0x63, 0x3d, 0xbb, 0xb6, 0x97, 0xe2, 0x70, 0x46, 0xb4, 0x66, + 0xc8, 0x31, 0xc9, 0x91, 0x57, 0x49, 0x36, 0x37, 0x1c, 0xf2, 0xce, 0xcc, 0x5d, 0x71, 0x78, 0x69, + 0x5e, 0x52, 0xf2, 0x2c, 0x50, 0x20, 0x48, 0xd1, 0x06, 0x48, 0xd0, 0x20, 0x49, 0x1b, 0x24, 0x41, + 0xda, 0x14, 0x45, 0xd1, 0x20, 0x05, 0x12, 0x34, 0x0d, 0x8a, 0x36, 0x08, 0x90, 0xa2, 0x48, 0xff, + 0x58, 0x24, 0x28, 0x92, 0x16, 0x2d, 0x90, 0xb6, 0x7f, 0x04, 0x6d, 0x93, 0xb6, 0x40, 0x0b, 0x14, + 0x68, 0x8b, 0xf6, 0x8f, 0xe0, 0xf7, 0x43, 0x7e, 0xdf, 0xe3, 0x9c, 0x73, 0xcf, 0x7d, 0x90, 0x33, + 0xf6, 0xee, 0xe2, 0x97, 0x05, 0xac, 0x1d, 0x9e, 0xd7, 0x3d, 0x8f, 0xef, 0x7c, 0xef, 0xf3, 0x7d, + 0xe2, 0x5a, 0xd7, 0x1b, 0xb5, 0xed, 0xc3, 0xce, 0xb1, 0xe3, 0xfb, 0xed, 0x43, 0xc7, 0xb7, 0x3b, + 0x3d, 0xd7, 0xe9, 0x8f, 0x8a, 0x83, 0xa1, 0x37, 0xf2, 0x0a, 0x17, 0xfc, 0x91, 0xd3, 0x3e, 0x56, + 0x75, 0xb2, 0x30, 0xde, 0xc5, 0x3b, 0x3e, 0xf6, 0xfa, 0xb2, 0xf6, 0xf2, 0x61, 0xc7, 0xef, 0x3e, + 0x33, 0xaa, 0x65, 0xf9, 0xad, 0xe4, 0x0f, 0xd9, 0x07, 0xed, 0xfe, 0xa8, 0xed, 0x9f, 0xc8, 0x56, + 0x97, 0xf6, 0xdb, 0xbe, 0x13, 0xeb, 0x6c, 0xfd, 0x30, 0x23, 0x2e, 0x95, 0x77, 0xfc, 0xc3, 0xe6, + 0xa8, 0x3d, 0x1c, 0x6d, 0xba, 0xfd, 0xae, 0xdb, 0x3f, 0xdc, 0x69, 0x8f, 0x3a, 0x47, 0xf9, 0x45, + 0x91, 0x79, 0xe6, 0x9c, 0xac, 0xa6, 0x6e, 0xa6, 0xde, 0x58, 0xc8, 0xdf, 0x10, 0x8b, 0xc7, 0x58, + 0x7a, 0x38, 0xf4, 0xc6, 0x03, 0x7f, 0x35, 0x0d, 0x85, 0xcb, 0xeb, 0xe2, 0xdd, 0xb5, 0x0f, 0xdf, + 0xfd, 0xf0, 0xfd, 0x0f, 0xd6, 0x3e, 0x7c, 0x2f, 0x7f, 0x59, 0xac, 0xc8, 0xcf, 0x3e, 0x77, 0x86, + 0xbe, 0xeb, 0xf5, 0x57, 0x33, 0xd8, 0x26, 0x7f, 0x5d, 0x88, 0xc3, 0xf6, 0xb1, 0x63, 0x1f, 0x7b, + 0x5d, 0xc7, 0x5f, 0xcd, 0xc6, 0xfa, 0x7d, 0x22, 0x56, 0xf6, 0xbd, 0x91, 0xdd, 0x75, 0x0f, 0x0e, + 0xdc, 0xce, 0xb8, 0x37, 0x3a, 0x59, 0x9d, 0x81, 0x36, 0x2b, 0x6b, 0xf9, 0xe2, 0x46, 0xbd, 0x55, + 0x7a, 0xe8, 0x8d, 0x36, 0x74, 0xcd, 0xfa, 0x85, 0x87, 0xf5, 0x96, 0xbd, 0x51, 0xdd, 0xdc, 0xac, + 0x96, 0xf7, 0xb6, 0x5b, 0x4f, 0xed, 0x47, 0xa5, 0xc6, 0x46, 0xfe, 0xbe, 0x10, 0x34, 0x33, 0x7b, + 0x74, 0x32, 0x70, 0x56, 0x67, 0xa9, 0xb3, 0x28, 0xd2, 0x12, 0x5a, 0x50, 0xb2, 0x7e, 0x7e, 0xa7, + 0xd4, 0x2a, 0x3f, 0xb2, 0x5b, 0x4f, 0x77, 0x2b, 0x76, 0xb9, 0xd4, 0xdc, 0x2b, 0x6d, 0xe7, 0x2d, + 0xb1, 0x42, 0x5d, 0x7a, 0xed, 0xfe, 0xe1, 0x18, 0xf7, 0x62, 0x75, 0x2e, 0x69, 0x3d, 0xc7, 0xed, + 0x81, 0x3d, 0x18, 0x3a, 0x07, 0xce, 0xd0, 0xe9, 0x77, 0x9c, 0xd5, 0x05, 0x5a, 0xcf, 0x39, 0x31, + 0x87, 0x07, 0x67, 0xbb, 0xdd, 0xd5, 0x79, 0x2a, 0x28, 0x8b, 0x3c, 0x2d, 0x50, 0x0d, 0x66, 0x3b, + 0xfd, 0xf1, 0xf1, 0xaa, 0xa0, 0x79, 0x9c, 0xe3, 0x79, 0x6c, 0xab, 0xef, 0xac, 0x5f, 0xe6, 0xc9, + 0x6c, 0x97, 0x6a, 0x5b, 0x7b, 0xa5, 0xad, 0x8a, 0x5d, 0xad, 0x3d, 0x29, 0x6d, 0x57, 0x37, 0xf2, + 0x85, 0xe8, 0x20, 0x7d, 0xf8, 0xb5, 0xba, 0x48, 0x5b, 0xff, 0xba, 0x58, 0x18, 0xc0, 0xa1, 0xd8, + 0xdd, 0xf6, 0xa8, 0xbd, 0xba, 0x04, 0x45, 0x8b, 0x6b, 0x17, 0x8a, 0x78, 0x64, 0x65, 0xda, 0xef, + 0x5d, 0xa8, 0xdb, 0x80, 0x2a, 0xeb, 0xb2, 0xb8, 0xc8, 0x07, 0xe9, 0x0d, 0xcc, 0x73, 0xb4, 0x7e, + 0x27, 0x25, 0x16, 0xb1, 0xa2, 0xe1, 0xb4, 0xbb, 0x27, 0x7b, 0x03, 0x98, 0xf0, 0x8c, 0x3f, 0x6a, + 0x8f, 0x1c, 0x3a, 0xd9, 0x95, 0xb5, 0x8b, 0xb4, 0xd1, 0xdb, 0xde, 0xfe, 0xfe, 0x09, 0xb5, 0x68, + 0x62, 0xdd, 0xfa, 0xf5, 0x84, 0x42, 0x7b, 0xaf, 0xb6, 0x51, 0x29, 0x6f, 0x97, 0x1a, 0x95, 0x8d, + 0xfc, 0x45, 0xb1, 0x34, 0xc4, 0x0a, 0x7b, 0x3c, 0xb0, 0x11, 0x4a, 0x10, 0x20, 0x66, 0xe1, 0x2c, + 0x56, 0x8e, 0xda, 0xc3, 0xee, 0x8b, 0xf6, 0xd0, 0xb1, 0xfd, 0x81, 0xd3, 0xf1, 0x09, 0x08, 0x16, + 0xd7, 0xae, 0x16, 0xcb, 0x38, 0x1e, 0x4f, 0xf8, 0x91, 0x6c, 0xd1, 0xc4, 0x06, 0xd6, 0x67, 0xe2, + 0xbc, 0x31, 0x39, 0xfc, 0xce, 0xd8, 0xcf, 0xe7, 0xc4, 0x7c, 0x0f, 0xbf, 0x8d, 0xbb, 0x9c, 0xa2, + 0x91, 0xe1, 0x7b, 0xed, 0x4e, 0xc7, 0x19, 0x8c, 0x9c, 0x2e, 0x14, 0x22, 0x00, 0x66, 0x60, 0xef, + 0xa1, 0xb4, 0xeb, 0x00, 0xd8, 0xf5, 0x65, 0x69, 0x06, 0x4b, 0xad, 0x5f, 0xca, 0x8a, 0x7c, 0xb9, + 0xe9, 0x8d, 0x87, 0x1d, 0xa7, 0xf5, 0x64, 0x0b, 0x36, 0xb2, 0x79, 0xdc, 0xee, 0xf5, 0xf2, 0x97, + 0xc4, 0x72, 0xbb, 0x33, 0x72, 0x9f, 0xe3, 0x4a, 0x46, 0xee, 0x31, 0xaf, 0x7f, 0x39, 0x7f, 0x45, + 0x9c, 0xeb, 0x3a, 0xe1, 0x8a, 0xb4, 0xaa, 0xf0, 0x9d, 0x21, 0x40, 0xb3, 0xed, 0xab, 0x13, 0xc7, + 0xd5, 0x64, 0x43, 0xb3, 0xcb, 0x52, 0xc9, 0x79, 0xb1, 0xd0, 0x73, 0xda, 0x87, 0x63, 0x07, 0x8b, + 0x66, 0xa8, 0x77, 0x5e, 0x08, 0x6e, 0xa4, 0xc1, 0x72, 0x19, 0x9b, 0xd1, 0x29, 0xd3, 0x47, 0x10, + 0xe4, 0x66, 0xf2, 0xcb, 0x62, 0xa6, 0xeb, 0xf4, 0xda, 0x27, 0x12, 0x98, 0xa0, 0x17, 0xee, 0x1b, + 0xec, 0x82, 0x37, 0xf4, 0x25, 0xc4, 0xa9, 0x5e, 0x78, 0x83, 0x08, 0xae, 0x96, 0xf3, 0x17, 0xc4, + 0x62, 0x1b, 0x26, 0x86, 0x80, 0x72, 0x7c, 0x3c, 0x24, 0x38, 0x59, 0xce, 0x5f, 0x15, 0xe7, 0x69, + 0x9e, 0x08, 0x3a, 0xf6, 0xb0, 0xdd, 0x75, 0xe1, 0xfa, 0xaf, 0x9e, 0x23, 0x10, 0x02, 0x60, 0x0e, + 0xaa, 0xba, 0xee, 0xd0, 0x59, 0xcd, 0x51, 0x39, 0x7e, 0xce, 0x1b, 0x8e, 0x6c, 0xbf, 0xe3, 0x41, + 0xd9, 0x79, 0x1a, 0x66, 0x55, 0xe4, 0x7a, 0x6d, 0x7f, 0x04, 0x07, 0xdb, 0xd5, 0x1b, 0x92, 0x87, + 0x9a, 0x34, 0x9d, 0x39, 0x0f, 0x6b, 0xc3, 0x6a, 0xbb, 0xab, 0x17, 0x68, 0x05, 0xb0, 0xad, 0xaa, + 0x94, 0x87, 0xb9, 0xa8, 0x56, 0x82, 0x1f, 0x92, 0x65, 0x97, 0xa8, 0xec, 0x4d, 0x31, 0x37, 0x80, + 0xb5, 0x02, 0x7e, 0x58, 0xbd, 0x0c, 0x27, 0xb5, 0xb8, 0x56, 0x28, 0xc6, 0xcf, 0xa9, 0xb8, 0x4b, + 0x4d, 0x70, 0xce, 0xfb, 0x63, 0xb7, 0x87, 0x70, 0x6c, 0x33, 0xbc, 0x5e, 0x81, 0x41, 0xe6, 0x0a, + 0xf7, 0xc4, 0xac, 0x6c, 0x01, 0x9f, 0x00, 0x98, 0xf0, 0xc6, 0xf0, 0x65, 0x09, 0x27, 0x74, 0x3d, + 0x8f, 0x9c, 0xa1, 0x87, 0x05, 0x74, 0x8a, 0xd6, 0xbf, 0x9d, 0x12, 0x56, 0x70, 0x59, 0x5a, 0xde, + 0x56, 0x19, 0x2f, 0x47, 0xcb, 0x1b, 0x98, 0x1f, 0xf6, 0x69, 0x27, 0x9c, 0xf6, 0x10, 0xd0, 0x48, + 0x80, 0xf3, 0x42, 0xa7, 0x9a, 0x8e, 0x0e, 0x9f, 0xd1, 0x07, 0x86, 0x98, 0xd3, 0xc6, 0x23, 0x62, + 0xf4, 0x86, 0x80, 0xc3, 0x97, 0xd9, 0x85, 0x6d, 0x84, 0x8f, 0x39, 0x5f, 0x4a, 0x98, 0xc0, 0x01, + 0x25, 0xe0, 0xf8, 0x00, 0x12, 0x99, 0x37, 0xb2, 0xd6, 0xdf, 0xa7, 0xc4, 0x5d, 0x9c, 0xde, 0x56, + 0xb9, 0xe5, 0xf1, 0x14, 0x93, 0xa6, 0xd7, 0x70, 0xfc, 0x81, 0xd7, 0xf7, 0x9d, 0x1f, 0xeb, 0x34, + 0xa1, 0x1f, 0x60, 0x2a, 0x2a, 0xf1, 0xe5, 0x04, 0x13, 0x66, 0xce, 0x90, 0xfb, 0xba, 0x84, 0x41, + 0xac, 0x00, 0xc8, 0xcd, 0x30, 0x0e, 0x8a, 0xdf, 0x31, 0x38, 0x34, 0x84, 0x5f, 0x17, 0x30, 0xb6, + 0x1c, 0x18, 0xe1, 0x7a, 0xde, 0xfa, 0x59, 0x71, 0x23, 0x7c, 0x08, 0xb0, 0x42, 0xc2, 0x4e, 0xb8, + 0xb6, 0x2f, 0xc6, 0x8e, 0x3f, 0x32, 0xe7, 0x9c, 0x52, 0xf0, 0xcc, 0xd0, 0x62, 0x1b, 0xa7, 0x9c, + 0x8e, 0x22, 0x61, 0x5a, 0x9f, 0x75, 0x5b, 0xbc, 0x16, 0x1b, 0x7f, 0x9b, 0x36, 0x25, 0xfc, 0x95, + 0xc4, 0x86, 0x9b, 0x43, 0xf8, 0xd1, 0x8d, 0x34, 0xfc, 0xa6, 0x78, 0x35, 0xdc, 0x50, 0xd6, 0xef, + 0xb8, 0x7d, 0x17, 0x96, 0xaa, 0x66, 0x0d, 0x9b, 0xc8, 0xd4, 0x07, 0x8f, 0x34, 0x45, 0x47, 0xba, + 0x2f, 0x6e, 0x4d, 0xef, 0x29, 0xcf, 0xf2, 0x75, 0x31, 0x77, 0xcc, 0x35, 0xd4, 0x71, 0x71, 0xed, + 0x12, 0x61, 0x75, 0x44, 0x94, 0xd4, 0x43, 0xb6, 0x27, 0x4c, 0x82, 0x17, 0x92, 0x1a, 0xd3, 0x06, + 0xcc, 0x5b, 0xbb, 0xe2, 0xf5, 0x30, 0xd4, 0xc4, 0xd7, 0x1b, 0xff, 0x4a, 0x7a, 0xca, 0x57, 0x12, + 0x47, 0x8c, 0x6c, 0xcc, 0x57, 0x9b, 0xb7, 0xf5, 0x6f, 0xa6, 0xc4, 0xb5, 0xc4, 0x9b, 0x27, 0x07, + 0x8c, 0x00, 0x65, 0x4a, 0x5f, 0x91, 0xd3, 0x80, 0x19, 0xda, 0x1c, 0xd0, 0xcc, 0x14, 0x02, 0x26, + 0x84, 0x28, 0x8b, 0x08, 0x42, 0x11, 0x9a, 0xe7, 0xb1, 0x50, 0x8e, 0x45, 0x85, 0xb3, 0xb4, 0x73, + 0xbf, 0x35, 0xe9, 0xc2, 0x25, 0x6f, 0xdf, 0x8f, 0x30, 0xc7, 0x00, 0x2e, 0xb2, 0x44, 0xac, 0x6e, + 0x04, 0xfb, 0x36, 0x43, 0xfb, 0xb6, 0x12, 0xde, 0x37, 0xeb, 0xae, 0xb8, 0x4c, 0x04, 0x9c, 0x09, + 0x80, 0xc3, 0xbb, 0x8f, 0x77, 0x0b, 0x29, 0x8e, 0xa6, 0x41, 0x44, 0x0f, 0x01, 0x3c, 0xaf, 0x27, + 0xb7, 0xd5, 0x33, 0xc7, 0xab, 0x68, 0x90, 0x2f, 0xb9, 0x55, 0xb3, 0xd6, 0x2a, 0x7f, 0xa5, 0xb4, + 0xdf, 0xee, 0x77, 0xbd, 0x7e, 0x79, 0x3c, 0x04, 0xee, 0x66, 0x84, 0x3d, 0xe1, 0x6e, 0x5c, 0x08, + 0xce, 0xab, 0x39, 0x86, 0x8b, 0x0c, 0x18, 0xa0, 0x8b, 0x1f, 0x47, 0x22, 0x00, 0x7c, 0x8d, 0xbc, + 0x99, 0xd6, 0xff, 0x2d, 0xc4, 0x4b, 0xd8, 0x72, 0x77, 0x88, 0x74, 0xb3, 0xe3, 0x10, 0x9f, 0xd0, + 0x74, 0x46, 0x1b, 0xce, 0xa8, 0xed, 0xf6, 0xe2, 0xe4, 0x3b, 0xab, 0x69, 0x18, 0xb1, 0x35, 0x69, + 0x42, 0x5b, 0x6f, 0x88, 0x25, 0x5a, 0x52, 0x97, 0x3b, 0x11, 0xed, 0x5e, 0x04, 0xb6, 0xaf, 0x4c, + 0xa3, 0xb5, 0xa0, 0x4a, 0x0d, 0x07, 0x14, 0x46, 0xae, 0x64, 0xe8, 0x1c, 0x22, 0x67, 0x99, 0x8d, + 0xd3, 0x45, 0xc6, 0x5f, 0x45, 0x31, 0xd7, 0x39, 0xb6, 0x07, 0x6e, 0xe7, 0x99, 0x64, 0x04, 0x97, + 0x89, 0xb9, 0xb1, 0xcb, 0x3b, 0xf6, 0x6e, 0xb5, 0xfc, 0x78, 0x7d, 0x45, 0xfd, 0x6a, 0x94, 0x6a, + 0x1b, 0xf5, 0x9d, 0x7c, 0x29, 0xc6, 0x7c, 0x2e, 0x4c, 0x64, 0x3e, 0x2f, 0x45, 0x98, 0xcf, 0x9d, + 0xca, 0x46, 0x75, 0x6f, 0x87, 0x18, 0x93, 0x5e, 0xcf, 0x7b, 0x61, 0xc3, 0xc1, 0xb6, 0x47, 0x3e, + 0x11, 0xe8, 0x79, 0xdc, 0xfc, 0x03, 0xb7, 0xd7, 0xb3, 0x5f, 0xb8, 0xa3, 0x23, 0x1b, 0x3e, 0xe1, + 0x13, 0x8d, 0x9e, 0x47, 0x70, 0x72, 0xfb, 0x23, 0x00, 0x14, 0x9a, 0xf4, 0x12, 0x95, 0x01, 0xc1, + 0xe5, 0x11, 0x24, 0xe5, 0x07, 0x82, 0xb7, 0xba, 0x4c, 0x35, 0xdf, 0x16, 0x4b, 0xb4, 0x42, 0xc5, + 0x51, 0xaf, 0xd0, 0xe4, 0x72, 0x34, 0x39, 0x3c, 0xb1, 0x27, 0x5c, 0xbe, 0x7e, 0x71, 0xab, 0xb4, + 0x53, 0xb1, 0x9f, 0x54, 0x1a, 0xcd, 0x6a, 0xbd, 0x66, 0x97, 0xf7, 0x1a, 0x8d, 0x4a, 0xad, 0x85, + 0xa7, 0x30, 0x68, 0xfb, 0x3e, 0x51, 0x0a, 0x66, 0x03, 0xf0, 0x5c, 0x08, 0x70, 0xe1, 0x5c, 0x72, + 0xb4, 0x61, 0x2f, 0x8b, 0x4b, 0x70, 0xca, 0x6d, 0x58, 0x1f, 0x90, 0xf4, 0xe7, 0x4e, 0x4f, 0xf3, + 0x0d, 0xcc, 0x0b, 0x00, 0x5b, 0x1a, 0xae, 0x26, 0xde, 0x21, 0x4f, 0x75, 0xb0, 0xf0, 0x9e, 0xd7, + 0xee, 0xd2, 0xc5, 0xc0, 0x83, 0xbe, 0xa0, 0x2e, 0x22, 0x9c, 0x95, 0x0b, 0x42, 0x08, 0xf1, 0x3d, + 0xcc, 0x0b, 0xbc, 0x24, 0x2e, 0x68, 0x16, 0x81, 0x2b, 0x5f, 0xb8, 0x7d, 0x5f, 0x32, 0x05, 0xb0, + 0x7c, 0x66, 0x14, 0x8c, 0x9a, 0xcb, 0x54, 0x73, 0x59, 0xcc, 0xc1, 0xc6, 0x74, 0x8e, 0xda, 0x23, + 0x22, 0xfd, 0xf3, 0xeb, 0x33, 0x07, 0xed, 0x1e, 0x40, 0xf6, 0x87, 0x62, 0x99, 0x24, 0x9e, 0xd1, + 0x73, 0x9b, 0x79, 0xa7, 0x55, 0xda, 0x97, 0xf3, 0x45, 0x82, 0x9c, 0x0d, 0xa8, 0x6a, 0x3d, 0xd9, + 0xc0, 0x8a, 0xf5, 0x73, 0x46, 0x89, 0x7d, 0x7f, 0xed, 0x1d, 0x94, 0x69, 0x80, 0xc5, 0x5e, 0xbd, + 0xaa, 0x36, 0xbe, 0x33, 0xf6, 0x47, 0x1e, 0xd3, 0x40, 0x3e, 0x92, 0x02, 0x6d, 0x14, 0xd0, 0x41, + 0x59, 0x83, 0x32, 0x00, 0x01, 0xed, 0x4b, 0x54, 0x01, 0x34, 0x49, 0x56, 0x18, 0x30, 0x73, 0x4d, + 0xce, 0x76, 0xc5, 0x1c, 0x0d, 0x76, 0xe4, 0x65, 0x02, 0x7d, 0xd8, 0x43, 0x35, 0x96, 0xdb, 0xb7, + 0x15, 0xff, 0x73, 0x5d, 0xed, 0xaf, 0xfe, 0xce, 0x97, 0xba, 0xee, 0x86, 0x24, 0xb9, 0xd7, 0x61, + 0xaa, 0xf6, 0x91, 0x07, 0xa8, 0x9f, 0xf8, 0xff, 0x91, 0x67, 0x87, 0xaf, 0xc1, 0x4d, 0x6a, 0xb7, + 0x21, 0xc4, 0x73, 0xd7, 0x77, 0xf7, 0xdd, 0x9e, 0x0b, 0x73, 0x79, 0x25, 0xca, 0xd3, 0x3f, 0xd1, + 0x75, 0xeb, 0x85, 0x84, 0x42, 0x7b, 0x77, 0xbc, 0xdf, 0x73, 0x3b, 0xc6, 0x8a, 0x69, 0xf6, 0x9d, + 0x61, 0x67, 0xd5, 0x22, 0xc6, 0x1b, 0xd9, 0x41, 0x46, 0x76, 0xf2, 0x80, 0x60, 0x61, 0xaf, 0xaa, + 0x05, 0xcb, 0x1a, 0xb5, 0xe0, 0x5b, 0x0a, 0xa6, 0xcc, 0xa1, 0x10, 0x77, 0x00, 0x0a, 0x3d, 0x1e, + 0xac, 0xbe, 0x86, 0xfc, 0x1b, 0xa0, 0xc1, 0x2b, 0x20, 0x54, 0x3d, 0x77, 0xbd, 0xb1, 0xcf, 0x24, + 0xcd, 0xf6, 0x60, 0x4d, 0x43, 0x17, 0x36, 0xff, 0x75, 0xda, 0x30, 0x5c, 0xb8, 0xfa, 0x62, 0x0f, + 0x6e, 0x04, 0x2c, 0x15, 0xc4, 0x30, 0xd7, 0x1b, 0xe2, 0x74, 0x11, 0x65, 0xac, 0xde, 0xa6, 0xef, + 0x3c, 0x16, 0x37, 0x27, 0xb7, 0xeb, 0x1c, 0x79, 0x80, 0x98, 0x56, 0xdf, 0xa0, 0xed, 0xb8, 0x5c, + 0x6c, 0xaa, 0x16, 0xbb, 0xb2, 0x01, 0x89, 0x86, 0x0b, 0x28, 0xd0, 0x6c, 0x56, 0x6b, 0x20, 0xcf, + 0xd4, 0xc5, 0x2d, 0x39, 0x58, 0x1f, 0x86, 0x99, 0x3c, 0xe0, 0x9d, 0xb3, 0x0e, 0x58, 0x13, 0xcb, + 0x83, 0xf6, 0xd8, 0xc7, 0xc9, 0x8d, 0xe8, 0x4a, 0xdf, 0x95, 0x3d, 0x35, 0x48, 0xee, 0x62, 0x75, + 0x93, 0x6b, 0xd7, 0x6f, 0x24, 0x16, 0xdb, 0x7b, 0xfd, 0x9e, 0x7b, 0xec, 0x82, 0xd0, 0x63, 0xfd, + 0x6d, 0x5a, 0x5c, 0x89, 0xe1, 0xdc, 0x32, 0xc8, 0x60, 0xa3, 0x64, 0xae, 0x10, 0x0e, 0x74, 0x04, + 0xec, 0x19, 0xc2, 0x6e, 0x5f, 0x52, 0x2f, 0x62, 0x1d, 0x10, 0xe6, 0x22, 0x15, 0x01, 0xd5, 0x02, + 0x4c, 0x6b, 0xd4, 0x69, 0xea, 0x6a, 0x62, 0x92, 0x19, 0x25, 0x50, 0x44, 0xa4, 0x7d, 0xe6, 0x13, + 0x1f, 0x88, 0x65, 0xc6, 0xfc, 0x0a, 0xab, 0xcf, 0x91, 0xfc, 0x77, 0xad, 0x38, 0x8d, 0x5c, 0xbc, + 0x2b, 0x16, 0x7c, 0x10, 0x67, 0x78, 0x92, 0xf3, 0xd4, 0xe1, 0x95, 0xe2, 0x84, 0xb5, 0x16, 0x9b, + 0xd0, 0x12, 0x71, 0x5f, 0xa1, 0x26, 0xe6, 0xd5, 0xdf, 0xf9, 0x25, 0x91, 0x25, 0xe9, 0x18, 0x97, + 0xbe, 0x84, 0xc4, 0x58, 0xcd, 0x2a, 0x4d, 0x22, 0x8a, 0x49, 0x3e, 0x33, 0x04, 0xd5, 0x40, 0x3b, + 0x7c, 0xf7, 0xb0, 0x0f, 0xc2, 0xe6, 0xd0, 0x91, 0x74, 0xf1, 0x3f, 0x90, 0xec, 0x4a, 0x74, 0x96, + 0x48, 0x89, 0x9a, 0x3d, 0x6f, 0x04, 0x6b, 0xcb, 0x12, 0xf4, 0xa5, 0x4c, 0xca, 0xb2, 0x55, 0xb6, + 0x5b, 0x95, 0xd2, 0xce, 0xfa, 0x65, 0xf3, 0x97, 0xbd, 0x55, 0xaf, 0x6f, 0xd8, 0x5b, 0x7b, 0x4f, + 0x9b, 0x38, 0x33, 0x1f, 0x3a, 0x4b, 0x36, 0xe1, 0x61, 0x8c, 0xde, 0x64, 0x26, 0xd2, 0x9b, 0xcb, + 0x11, 0x7a, 0xb3, 0x5b, 0x6a, 0x36, 0xab, 0x4f, 0x2a, 0xc0, 0xa8, 0x5d, 0x4d, 0x9a, 0x66, 0xd9, + 0x6b, 0x77, 0x8e, 0xbe, 0xd6, 0x1c, 0x91, 0x25, 0x7a, 0x2d, 0x36, 0xe4, 0xa7, 0x9e, 0xdb, 0x7f, + 0x38, 0x04, 0x04, 0xdf, 0x01, 0xde, 0xb3, 0x7c, 0xd4, 0xee, 0xf7, 0x9d, 0x1e, 0xee, 0x6c, 0x87, + 0xff, 0x94, 0xac, 0x10, 0xd2, 0x0f, 0xd2, 0x90, 0x0c, 0x41, 0x02, 0xef, 0x3a, 0x7e, 0x67, 0xe8, + 0x0e, 0x46, 0x6a, 0xe3, 0x17, 0xf2, 0xd7, 0xc5, 0xe5, 0xa0, 0x9a, 0x78, 0xf8, 0x21, 0xdc, 0x24, + 0xc4, 0xb3, 0x19, 0xa9, 0x55, 0xba, 0x12, 0xd4, 0x6b, 0xdd, 0x07, 0x35, 0xc0, 0x43, 0x59, 0xb0, + 0x3e, 0x64, 0xae, 0x34, 0x0c, 0x08, 0x3d, 0xcf, 0x77, 0x4e, 0x9d, 0x1a, 0x70, 0x48, 0xef, 0xc7, + 0xba, 0xb6, 0xbc, 0xc3, 0xc3, 0x5e, 0xac, 0x6f, 0x19, 0x40, 0x68, 0xd8, 0x3e, 0x6e, 0xf7, 0x59, + 0xfb, 0x60, 0xbd, 0xc9, 0x1a, 0xb1, 0x50, 0xcf, 0xc7, 0xc0, 0x53, 0x44, 0x04, 0x4e, 0x96, 0x3c, + 0x1e, 0x88, 0x97, 0x13, 0x1b, 0x6f, 0x0e, 0xbd, 0x63, 0x04, 0x9d, 0x24, 0x29, 0x55, 0xf1, 0x60, + 0xa1, 0x4e, 0xc0, 0x7f, 0x3e, 0x77, 0xac, 0xfb, 0x09, 0xb7, 0x7c, 0xbb, 0x3d, 0xee, 0xc3, 0xd9, + 0xc6, 0xef, 0x1c, 0x31, 0x3d, 0xd6, 0xdb, 0x0c, 0xb7, 0xa5, 0xc1, 0xa0, 0x47, 0x6c, 0x53, 0xcb, + 0x0b, 0xf5, 0x36, 0x85, 0x25, 0xfe, 0xfa, 0x35, 0x51, 0x60, 0x3e, 0x0f, 0x70, 0x46, 0x78, 0x7b, + 0xa0, 0x99, 0xf5, 0x4b, 0xa9, 0x84, 0xe5, 0x6f, 0x03, 0x03, 0x8d, 0xa4, 0x20, 0x82, 0x39, 0x7c, + 0x1a, 0x71, 0x3e, 0x84, 0x20, 0xf8, 0xe4, 0x57, 0xc4, 0xac, 0xa4, 0x52, 0x8c, 0x59, 0xde, 0x33, + 0x99, 0xb5, 0x2c, 0x41, 0xe7, 0x8a, 0x84, 0x4e, 0x28, 0xde, 0x81, 0xd2, 0xf5, 0x3c, 0xff, 0x04, + 0x56, 0x66, 0xa7, 0xbe, 0x51, 0xb1, 0x6b, 0xf5, 0x5a, 0xc5, 0xfa, 0xab, 0x2c, 0x4b, 0xef, 0xb1, + 0xc9, 0x28, 0x36, 0xb7, 0x82, 0x20, 0x05, 0xdf, 0x4f, 0x2b, 0x56, 0xf3, 0x61, 0xf6, 0xe7, 0x7f, + 0xef, 0xe5, 0x54, 0x1c, 0x93, 0x65, 0x14, 0xc1, 0x4d, 0x40, 0x7e, 0x8c, 0xe5, 0x4a, 0xc0, 0x9f, + 0x3b, 0xc7, 0xfb, 0x48, 0x81, 0x99, 0x3f, 0x7f, 0xa7, 0x78, 0xfa, 0xa7, 0x25, 0xbb, 0xba, 0x43, + 0x1d, 0x91, 0x3d, 0x18, 0x82, 0x60, 0x08, 0xec, 0x8c, 0x6f, 0xeb, 0x0d, 0x21, 0xb9, 0x03, 0xab, + 0x50, 0x69, 0x12, 0x96, 0x66, 0xe7, 0x14, 0x7a, 0x3d, 0x44, 0x4d, 0x47, 0xa0, 0x53, 0x04, 0x98, + 0xe1, 0x92, 0x9e, 0x77, 0xe8, 0x11, 0x4f, 0x9a, 0x45, 0x4c, 0x42, 0x8c, 0x88, 0xa0, 0xfd, 0x4d, + 0xe2, 0x5d, 0x58, 0x5d, 0x18, 0xda, 0xe9, 0xa5, 0xb3, 0xee, 0x34, 0x71, 0xac, 0x2c, 0x41, 0xc1, + 0x8d, 0xf4, 0x61, 0x77, 0x24, 0x0f, 0x7a, 0x2e, 0xd0, 0xd9, 0xac, 0x28, 0x1d, 0x41, 0x94, 0x37, + 0x3a, 0xa7, 0xa6, 0x14, 0x70, 0x31, 0x7c, 0xdb, 0x25, 0x97, 0x19, 0x63, 0xe0, 0xcf, 0x9f, 0x91, + 0xc3, 0xc9, 0xc7, 0xe5, 0x2d, 0x62, 0x33, 0x0b, 0x1f, 0x88, 0xa5, 0xd0, 0xc6, 0x27, 0xa9, 0x82, + 0x80, 0x15, 0x95, 0x73, 0x09, 0xa4, 0x0e, 0xcb, 0x4b, 0xb8, 0xae, 0xe6, 0xa1, 0x4e, 0x01, 0xf2, + 0x77, 0xc5, 0x1c, 0xd2, 0x36, 0x57, 0x4b, 0xd2, 0xaf, 0x9e, 0x01, 0x3e, 0xac, 0x9f, 0x13, 0xcb, + 0xd8, 0xca, 0xbc, 0x45, 0x91, 0xcd, 0xa0, 0xd9, 0xae, 0xa7, 0xde, 0x09, 0x9f, 0x5c, 0xfa, 0xcc, + 0x77, 0x64, 0x87, 0xef, 0x6b, 0x7c, 0x29, 0xc6, 0x84, 0x53, 0x67, 0x9f, 0xf0, 0x2f, 0x27, 0xdd, + 0x7f, 0xa4, 0x06, 0x09, 0x62, 0x5d, 0x1c, 0x25, 0xa5, 0x63, 0x0c, 0x43, 0x26, 0xc2, 0x51, 0x6b, + 0xfe, 0x92, 0xc8, 0xee, 0x64, 0x6e, 0x11, 0x91, 0xdb, 0x9c, 0x65, 0x27, 0x9c, 0x17, 0x4e, 0x46, + 0x2f, 0xf2, 0x63, 0x44, 0x34, 0x3e, 0x50, 0xcc, 0x90, 0x3a, 0x1b, 0x9b, 0x48, 0xed, 0x35, 0xd6, + 0xad, 0xaf, 0xd2, 0xbe, 0x7d, 0x5a, 0xaf, 0xd6, 0xec, 0x46, 0xa5, 0x09, 0xf4, 0xd4, 0x6e, 0xee, + 0x95, 0xcb, 0x95, 0x66, 0xd3, 0x7a, 0x8f, 0x11, 0x0c, 0x0b, 0xd0, 0x09, 0x5b, 0xa3, 0x95, 0x53, + 0x7c, 0x3b, 0x78, 0x2b, 0x97, 0xad, 0x9f, 0x66, 0xf5, 0xd0, 0xc4, 0x6e, 0x3f, 0xd2, 0x11, 0x7c, + 0xc0, 0xf4, 0x78, 0x0b, 0x51, 0x00, 0xb0, 0xc8, 0xce, 0xc4, 0x69, 0x01, 0x96, 0x25, 0x3c, 0xa1, + 0x66, 0xf5, 0xb3, 0x52, 0x89, 0x33, 0xa5, 0xe3, 0x8f, 0x34, 0xb1, 0x6f, 0xf1, 0x66, 0xe1, 0xee, + 0xb6, 0xf7, 0x7b, 0x4e, 0x99, 0x0e, 0x4e, 0x01, 0xa7, 0xd6, 0xe4, 0x5d, 0x4a, 0x84, 0x70, 0xeb, + 0x58, 0xbc, 0x31, 0xb5, 0xb3, 0x89, 0xd0, 0xe3, 0xc2, 0x14, 0x03, 0x1c, 0xaa, 0x74, 0x08, 0x04, + 0x19, 0xbd, 0xa4, 0x95, 0x24, 0x1a, 0x42, 0x3a, 0x4c, 0x98, 0xbb, 0x7c, 0x42, 0xa7, 0x7c, 0x2e, + 0xff, 0x51, 0xc8, 0x3e, 0xc5, 0x7b, 0x71, 0xa7, 0x78, 0xd6, 0x89, 0x5a, 0x9f, 0x89, 0x9b, 0xf1, + 0xb6, 0xdb, 0xbc, 0xb3, 0xd3, 0xf7, 0x23, 0x61, 0x8d, 0xb8, 0x9c, 0xac, 0xf5, 0x9f, 0xa4, 0xf9, + 0x14, 0x27, 0x8c, 0x19, 0xa6, 0x7b, 0x51, 0x3b, 0xc9, 0x84, 0x41, 0x03, 0x73, 0x04, 0xe1, 0x42, + 0xbe, 0x93, 0xb0, 0x6f, 0x4c, 0xf0, 0xe4, 0xbe, 0x65, 0x95, 0xda, 0x35, 0x4e, 0xa8, 0x66, 0x14, + 0x46, 0x95, 0x55, 0x34, 0xca, 0xec, 0x24, 0x59, 0x79, 0x6e, 0x22, 0x3d, 0x98, 0x4f, 0xa6, 0x07, + 0x0b, 0x67, 0xa4, 0x07, 0x42, 0x9d, 0xf7, 0x51, 0xdb, 0x20, 0xb0, 0xa4, 0x5a, 0xb1, 0xbe, 0x27, + 0x5e, 0x39, 0x75, 0xd7, 0xf2, 0xdf, 0x8c, 0x82, 0xfd, 0xed, 0xe2, 0xd9, 0xb6, 0xda, 0xfa, 0x87, + 0xb4, 0x58, 0xc5, 0xa6, 0x9f, 0x8d, 0x81, 0xb9, 0xc3, 0xf6, 0x41, 0xdb, 0x93, 0xfc, 0x35, 0x71, + 0xb1, 0xe7, 0x1c, 0xb6, 0x3b, 0x27, 0xf6, 0x57, 0x38, 0xe8, 0x89, 0x26, 0xd3, 0x75, 0x71, 0xb1, + 0x43, 0xc2, 0x8e, 0x1d, 0x96, 0xa5, 0xb2, 0x67, 0x90, 0xa5, 0xd0, 0xc8, 0x45, 0xca, 0xa4, 0x76, + 0xff, 0x04, 0x0f, 0x44, 0xaa, 0x42, 0xb7, 0xc4, 0x05, 0x39, 0x41, 0x9e, 0x19, 0xed, 0x2f, 0xdb, + 0x20, 0x16, 0xd7, 0xee, 0x16, 0x27, 0x2d, 0xac, 0xb8, 0x4d, 0x9d, 0x1a, 0xd4, 0x07, 0x0d, 0x8d, + 0x61, 0x63, 0xe4, 0xdc, 0x44, 0x63, 0x64, 0x61, 0x5b, 0xe4, 0x62, 0x7d, 0x27, 0xdc, 0x03, 0x60, + 0x6c, 0x70, 0x48, 0x79, 0x99, 0x01, 0xc6, 0xe4, 0x14, 0xb5, 0x9c, 0x30, 0x67, 0xed, 0xf3, 0x2d, + 0x4b, 0x9a, 0xe2, 0x8f, 0x8d, 0x10, 0xfc, 0x30, 0xc5, 0x96, 0x48, 0x90, 0xc2, 0xf0, 0xae, 0x4f, + 0x11, 0xad, 0x27, 0x51, 0xbd, 0x8f, 0xd1, 0xe4, 0xf5, 0xf5, 0x25, 0x3b, 0x2d, 0xbc, 0x65, 0xbf, + 0x8a, 0x80, 0x19, 0xd7, 0x82, 0x5a, 0xbf, 0x92, 0x62, 0x4b, 0x70, 0x80, 0xb8, 0xbe, 0xc6, 0x62, + 0xf2, 0xb1, 0xc5, 0x44, 0x34, 0xae, 0x24, 0xa0, 0xa1, 0x42, 0x4d, 0x41, 0xd9, 0x42, 0x02, 0xa0, + 0xcf, 0x11, 0x46, 0xfb, 0x37, 0x52, 0xac, 0x59, 0xae, 0x3c, 0x97, 0xaa, 0xe6, 0x7f, 0xc9, 0xf3, + 0xb9, 0xc9, 0xca, 0x73, 0x89, 0x9f, 0xab, 0xfd, 0x91, 0x03, 0xfc, 0x1e, 0x8a, 0xad, 0xed, 0x5e, + 0x0b, 0x20, 0xcc, 0x19, 0x59, 0x05, 0xbe, 0xec, 0x0f, 0xdb, 0x80, 0x90, 0x3a, 0x4e, 0xb7, 0x79, + 0x34, 0x3e, 0x38, 0xe8, 0xf1, 0x65, 0x03, 0x99, 0x94, 0x80, 0xb1, 0xda, 0x77, 0x47, 0x6e, 0xbb, + 0xf7, 0x19, 0x0e, 0x01, 0x5d, 0xfb, 0x6d, 0xe0, 0xfa, 0x35, 0x30, 0x02, 0xa8, 0xbb, 0x5c, 0x6f, + 0xfb, 0xcf, 0xdc, 0x9e, 0x92, 0x49, 0xff, 0x97, 0x8b, 0xcc, 0x0d, 0x6a, 0x9d, 0x3f, 0x36, 0x3c, + 0xf4, 0xbc, 0xae, 0x7d, 0x38, 0x3e, 0x21, 0xdd, 0xa7, 0x54, 0xd2, 0x00, 0x62, 0xef, 0x8e, 0x87, + 0x34, 0xa7, 0x60, 0xad, 0x64, 0x88, 0x68, 0xb9, 0xd2, 0x80, 0x37, 0x87, 0x86, 0x18, 0xc5, 0x9a, + 0xcf, 0x24, 0x19, 0x62, 0x94, 0x25, 0x15, 0x06, 0x53, 0xb6, 0x08, 0xc2, 0xd9, 0x59, 0xc4, 0xa0, + 0x23, 0xef, 0x05, 0x99, 0x06, 0x50, 0xe2, 0x05, 0xb4, 0x9c, 0x61, 0xce, 0x7e, 0xbf, 0x3d, 0x04, + 0xc4, 0xf2, 0xcc, 0x57, 0x15, 0x0b, 0x54, 0x81, 0xb2, 0x75, 0x0f, 0x36, 0xd2, 0x19, 0x4a, 0x0c, + 0x0c, 0xa8, 0xfd, 0xc0, 0x1d, 0x02, 0x9a, 0xde, 0xef, 0xe1, 0xe4, 0xc9, 0x46, 0xbc, 0x14, 0x5c, + 0x5f, 0x9c, 0x95, 0xed, 0xb7, 0x7b, 0x2c, 0x43, 0xcc, 0xd1, 0xdc, 0xf9, 0xe2, 0xbb, 0x03, 0x92, + 0x22, 0xe6, 0xa4, 0x9e, 0x18, 0x8b, 0x06, 0xde, 0x90, 0xcd, 0xd4, 0x51, 0x9b, 0xb9, 0x96, 0x1d, + 0x8e, 0xc6, 0x20, 0x9b, 0x6b, 0xed, 0xe8, 0x79, 0x55, 0xac, 0x2c, 0xe0, 0xbc, 0xc1, 0x5a, 0x29, + 0x4d, 0x47, 0xbd, 0xcf, 0x07, 0x47, 0xd2, 0x42, 0x1a, 0x17, 0xa6, 0xf4, 0xcf, 0x4a, 0x12, 0xbe, + 0xa8, 0x9a, 0x93, 0xee, 0x59, 0x95, 0x5e, 0x52, 0xdc, 0xab, 0x56, 0x93, 0x5f, 0x56, 0x34, 0x31, + 0x34, 0x00, 0x51, 0xb9, 0x2b, 0x0a, 0xc6, 0x82, 0x21, 0xa8, 0x7c, 0x55, 0x69, 0x8a, 0x43, 0x5d, + 0x48, 0x92, 0xbb, 0xaa, 0xf0, 0x7e, 0xd0, 0x85, 0xca, 0x0b, 0x54, 0x0e, 0xac, 0x70, 0xa8, 0x4b, + 0xc7, 0x3b, 0x1e, 0xf4, 0x9c, 0x11, 0xeb, 0x9e, 0x49, 0x76, 0x0d, 0xba, 0xe9, 0x3a, 0xad, 0x7c, + 0x1e, 0x78, 0x3e, 0x00, 0xdc, 0x73, 0xc7, 0x7e, 0xee, 0x8d, 0x80, 0xbc, 0xbd, 0xac, 0xca, 0xfb, + 0x80, 0x86, 0x8d, 0xf2, 0xeb, 0x71, 0x71, 0xfc, 0xc6, 0x99, 0x85, 0xc4, 0xbb, 0x42, 0xa0, 0x71, + 0xc5, 0x87, 0xfd, 0xed, 0xfb, 0xab, 0x37, 0x09, 0xe8, 0x2e, 0x17, 0xd9, 0xc0, 0xf9, 0xc8, 0x19, + 0x7a, 0xac, 0x15, 0xa5, 0x6b, 0x8e, 0x27, 0xc4, 0x50, 0xe7, 0x3b, 0x5f, 0xd8, 0xe8, 0x12, 0xf3, + 0x0a, 0x2d, 0xf2, 0x21, 0x3a, 0x8e, 0x30, 0x80, 0x90, 0x51, 0xdf, 0xa2, 0x8f, 0x17, 0x22, 0x90, + 0xdb, 0xa0, 0x26, 0xec, 0x8a, 0x92, 0x6b, 0x54, 0x76, 0xb7, 0x4b, 0x4f, 0xed, 0xd2, 0x93, 0x52, + 0x75, 0xbb, 0xf4, 0x70, 0xbb, 0x82, 0xe0, 0xa7, 0x36, 0x4a, 0x0b, 0xce, 0xaf, 0x2a, 0xb0, 0xa0, + 0x3d, 0xd2, 0xc5, 0xb7, 0x14, 0xbc, 0x86, 0x76, 0x76, 0xd4, 0x3e, 0x24, 0x6d, 0xf4, 0x82, 0xee, + 0xa0, 0x8b, 0x5f, 0x57, 0x36, 0xf5, 0x40, 0xdd, 0x7d, 0x3b, 0xc9, 0xb2, 0xf1, 0x06, 0x15, 0x7e, + 0x22, 0x2e, 0xee, 0x2b, 0x6d, 0x12, 0x32, 0x39, 0xac, 0x50, 0xf2, 0x57, 0xdf, 0xa4, 0xad, 0x79, + 0x25, 0xb2, 0xaa, 0x87, 0x41, 0x53, 0xa5, 0xb6, 0x02, 0x0e, 0xde, 0xe9, 0x1f, 0xba, 0x7d, 0x67, + 0xf5, 0x2d, 0x1a, 0xf0, 0x83, 0xb0, 0x5c, 0x4f, 0x64, 0xf6, 0x1e, 0x91, 0xd9, 0x97, 0x23, 0x83, + 0x05, 0xd8, 0x9d, 0x08, 0xee, 0x1f, 0x2d, 0x4c, 0xf5, 0x8b, 0x08, 0x84, 0x61, 0x43, 0x1d, 0x19, + 0xb3, 0x5a, 0xc2, 0x6c, 0xdc, 0x91, 0x73, 0x6c, 0xbf, 0x23, 0x79, 0x41, 0xf5, 0xfb, 0xbe, 0x64, + 0x00, 0xd5, 0xef, 0x35, 0xa9, 0xee, 0x55, 0xbf, 0x1f, 0x48, 0x4d, 0x86, 0xfa, 0xfd, 0xae, 0x64, + 0xf4, 0xd4, 0xef, 0xf7, 0x24, 0x87, 0x67, 0x89, 0x82, 0xf3, 0x25, 0x5a, 0xb9, 0x9c, 0xae, 0x02, + 0x63, 0x60, 0xae, 0xdc, 0xfd, 0xf1, 0x48, 0x71, 0x77, 0x69, 0xe2, 0x12, 0x3a, 0xed, 0x1e, 0xb4, + 0x38, 0x76, 0xa0, 0xae, 0x43, 0xec, 0x1d, 0x15, 0x6b, 0xb3, 0xc1, 0xb0, 0xdd, 0x7f, 0x66, 0xe0, + 0x1b, 0xf8, 0x45, 0x3b, 0x7f, 0xe8, 0x10, 0xbe, 0x61, 0x5c, 0xe9, 0xf5, 0x3c, 0x6e, 0x77, 0x9f, + 0x10, 0xea, 0xb2, 0x98, 0x41, 0x34, 0xa1, 0x94, 0x18, 0x30, 0xb1, 0x2e, 0x90, 0xa0, 0x23, 0x5f, + 0x62, 0x1e, 0xd8, 0x09, 0xe0, 0x26, 0x41, 0xde, 0xf1, 0x03, 0xb4, 0xd3, 0x43, 0x85, 0x9c, 0x46, + 0x91, 0xe7, 0x15, 0xaf, 0x72, 0xe8, 0xf5, 0xba, 0x86, 0x62, 0x02, 0x2d, 0xf3, 0x47, 0x2e, 0xf4, + 0xbb, 0x10, 0x0c, 0xdc, 0x47, 0xfe, 0x52, 0x63, 0x18, 0xec, 0x60, 0x0f, 0x60, 0xa4, 0x63, 0x40, + 0xef, 0x97, 0x14, 0xa2, 0xfb, 0xee, 0xae, 0x2e, 0xbb, 0xac, 0x75, 0x3e, 0xd8, 0x12, 0xcd, 0xae, + 0x6c, 0xf0, 0xa2, 0xd5, 0xd1, 0x01, 0x75, 0xdb, 0xc7, 0x80, 0xe9, 0x08, 0xb3, 0x2c, 0x07, 0xc8, + 0x5b, 0x96, 0x5e, 0xd5, 0x4c, 0x31, 0x36, 0x3d, 0x72, 0xda, 0x3d, 0xe4, 0xa6, 0x0a, 0x54, 0x0a, + 0xcb, 0x26, 0xc3, 0x9d, 0x44, 0x21, 0xe8, 0x07, 0xe4, 0x92, 0x9b, 0x99, 0x8f, 0xa6, 0x38, 0xa7, + 0x2f, 0xd1, 0x47, 0x44, 0x55, 0xf2, 0x32, 0xdd, 0x01, 0x40, 0x47, 0xfe, 0x78, 0x80, 0xe8, 0xd9, + 0x6e, 0x4b, 0x63, 0xd1, 0xf3, 0x76, 0x6f, 0xec, 0x48, 0x14, 0x82, 0x34, 0xc0, 0x71, 0xc8, 0x3d, + 0x07, 0x18, 0x54, 0x3a, 0x53, 0xb2, 0x48, 0xcd, 0xf3, 0x4d, 0x21, 0xb2, 0x4e, 0x07, 0x60, 0x51, + 0xf3, 0x1b, 0xe2, 0x8a, 0x51, 0x68, 0x8f, 0x01, 0x3b, 0x0f, 0x81, 0x65, 0xed, 0x03, 0x31, 0x7f, + 0x55, 0x35, 0x88, 0xd6, 0xa8, 0x53, 0xbd, 0x45, 0x5a, 0x7c, 0xc0, 0xe2, 0xb4, 0x42, 0x42, 0x1e, + 0x2c, 0x4e, 0xbc, 0x16, 0x68, 0x1b, 0x86, 0x23, 0x92, 0x82, 0x5e, 0x57, 0xde, 0x62, 0x12, 0x86, + 0xf8, 0xd0, 0x6f, 0x47, 0x20, 0x4b, 0x9e, 0xfd, 0x1b, 0x54, 0x8c, 0x86, 0x72, 0x2e, 0x56, 0x20, + 0x70, 0x87, 0xca, 0xd1, 0xd6, 0xd7, 0x6b, 0xc3, 0x76, 0x75, 0xed, 0x83, 0xf6, 0x10, 0x2e, 0x24, + 0x1e, 0xfc, 0x5d, 0xb5, 0xd9, 0x6a, 0x6b, 0xa8, 0xf4, 0x4d, 0xcd, 0xe7, 0xcb, 0x0e, 0x12, 0x06, + 0xde, 0x8a, 0x96, 0x1f, 0xbb, 0xbe, 0x0f, 0xe5, 0xf7, 0x14, 0xac, 0xc8, 0xdf, 0x45, 0x89, 0x94, + 0x73, 0x6a, 0xa3, 0xc7, 0x83, 0x43, 0x40, 0x58, 0x50, 0xf3, 0x36, 0x21, 0x92, 0x97, 0x24, 0x8e, + 0xe5, 0x0b, 0x5e, 0xe2, 0x46, 0x7b, 0xdc, 0x06, 0x30, 0x6a, 0xa1, 0xdd, 0xed, 0xba, 0xcc, 0xbf, + 0xc0, 0xf6, 0x01, 0x30, 0xda, 0x6e, 0x1f, 0x71, 0xb0, 0x37, 0x3c, 0x59, 0x7d, 0x87, 0x06, 0xb8, + 0x2e, 0x07, 0x28, 0xe9, 0x86, 0x7b, 0xd0, 0xae, 0xaa, 0x5a, 0x01, 0xeb, 0x1a, 0x47, 0x3b, 0x6b, + 0x84, 0x76, 0x6e, 0x25, 0xf2, 0x14, 0x51, 0xec, 0xf3, 0x40, 0xac, 0x84, 0x4b, 0xf0, 0x6e, 0xb0, + 0x91, 0x56, 0x99, 0x23, 0x68, 0xbd, 0xc0, 0xe1, 0xf4, 0x81, 0x8b, 0x20, 0x26, 0x07, 0x3a, 0x9d, + 0x33, 0x30, 0x62, 0xb5, 0x7f, 0xe0, 0x25, 0xa2, 0x2e, 0xa5, 0xf8, 0x24, 0x05, 0x5e, 0xe1, 0xd7, + 0x52, 0x22, 0x9f, 0x80, 0x47, 0xe1, 0x44, 0x42, 0xf6, 0x05, 0x66, 0x26, 0x01, 0x12, 0xe3, 0x46, + 0x89, 0x0f, 0xc5, 0x79, 0x13, 0x67, 0xbb, 0xf0, 0x5d, 0xe5, 0x7d, 0x70, 0x7d, 0x32, 0xc2, 0xa6, + 0xe9, 0x21, 0x56, 0x88, 0x5b, 0x29, 0x0a, 0xeb, 0xb1, 0xd5, 0x4f, 0xd2, 0x5f, 0x10, 0x2b, 0x36, + 0x30, 0x15, 0x92, 0xbb, 0x62, 0xd1, 0x20, 0x76, 0xb0, 0x8e, 0x18, 0xb9, 0xcb, 0x7d, 0x03, 0x40, + 0xff, 0x82, 0x2c, 0xad, 0x81, 0xe8, 0xd0, 0xa8, 0x94, 0xeb, 0x8d, 0x8d, 0xca, 0x46, 0x2e, 0x05, + 0xfb, 0xb5, 0x22, 0x2b, 0x2a, 0xdf, 0xdd, 0xad, 0x36, 0xa0, 0x2c, 0x6d, 0xbd, 0xcd, 0xea, 0x7d, + 0x5c, 0x05, 0x1f, 0x16, 0x93, 0x67, 0x80, 0x6c, 0x3c, 0xe9, 0x04, 0x87, 0xa5, 0xff, 0x32, 0xcb, + 0xf2, 0x42, 0xcc, 0xf3, 0xc8, 0x64, 0x1c, 0x53, 0x61, 0x3f, 0x32, 0xed, 0x27, 0x39, 0x97, 0xc0, + 0xab, 0x7e, 0x3d, 0x65, 0x3f, 0x9e, 0x21, 0xc2, 0x07, 0x49, 0xfe, 0x08, 0x35, 0x4c, 0x73, 0xee, + 0x05, 0x5c, 0x2e, 0x8b, 0xab, 0xd7, 0x12, 0xdd, 0x8d, 0x14, 0xb3, 0xfb, 0x96, 0x98, 0x65, 0xe6, + 0x2d, 0x64, 0x7a, 0x8c, 0xb5, 0x66, 0x6f, 0x9f, 0x42, 0xef, 0x2b, 0x39, 0x13, 0x06, 0x54, 0x24, + 0x13, 0xa1, 0x22, 0xd9, 0x28, 0x15, 0x99, 0x51, 0xed, 0x91, 0xfe, 0xf1, 0xcc, 0x97, 0x0b, 0xff, + 0x63, 0x4a, 0xcc, 0xf2, 0x87, 0xc3, 0x3a, 0x6d, 0xed, 0x88, 0x1a, 0xe5, 0x52, 0xd3, 0x93, 0xb9, + 0xcf, 0xcc, 0x64, 0x2e, 0x33, 0xab, 0x70, 0x60, 0x88, 0xb7, 0x9d, 0x51, 0xb8, 0x28, 0xc2, 0xae, + 0xce, 0xc6, 0xd9, 0x58, 0x1a, 0x65, 0x8e, 0x46, 0x89, 0x70, 0x3d, 0xf3, 0x11, 0x56, 0x88, 0x4c, + 0xb6, 0x44, 0xdb, 0x2d, 0x2f, 0x00, 0x3b, 0x13, 0xe0, 0x36, 0xdd, 0x1e, 0xdc, 0x9e, 0x04, 0xb0, + 0xcb, 0xbf, 0x26, 0x5e, 0xee, 0x3b, 0x2f, 0x1c, 0xe5, 0xd9, 0x06, 0x35, 0x76, 0x7b, 0xc4, 0xa4, + 0x09, 0xe4, 0xb2, 0xe1, 0x89, 0xd4, 0x92, 0xa0, 0x21, 0x5b, 0xd3, 0x2c, 0xae, 0x60, 0x05, 0xdf, + 0xbf, 0x97, 0x61, 0x2b, 0x1a, 0x7e, 0x51, 0x8a, 0x72, 0xca, 0xb3, 0x2c, 0x76, 0x70, 0x21, 0x49, + 0x31, 0xa3, 0xa8, 0x06, 0x39, 0xb8, 0x22, 0x05, 0x9e, 0xd5, 0x80, 0x4c, 0x25, 0xed, 0x2f, 0x69, + 0xf5, 0x73, 0xb8, 0xbd, 0xd2, 0x65, 0xcb, 0x1e, 0xf2, 0x17, 0x80, 0xc8, 0x09, 0x75, 0x28, 0x7c, + 0x13, 0xda, 0xc1, 0xfc, 0x89, 0x55, 0x21, 0x25, 0xa5, 0xe9, 0xea, 0xb1, 0x44, 0x43, 0x01, 0x7c, + 0xc9, 0x21, 0xb0, 0xe1, 0xb2, 0xb2, 0x9e, 0x46, 0x6d, 0x0d, 0xb6, 0xd7, 0xef, 0x9d, 0x10, 0x93, + 0x32, 0x1f, 0x01, 0xc9, 0x73, 0x71, 0x5b, 0x08, 0xb3, 0x2a, 0xef, 0x8b, 0x19, 0x16, 0x81, 0xce, + 0xd3, 0x4d, 0xb3, 0x8a, 0xc9, 0x9b, 0x52, 0x6c, 0x62, 0xa3, 0x6d, 0xe4, 0x06, 0xd6, 0x33, 0xa5, + 0x7e, 0xc8, 0x2e, 0x98, 0x9f, 0xa0, 0xa7, 0xba, 0x48, 0xe2, 0xf2, 0x87, 0x42, 0x04, 0x7d, 0xf3, + 0x73, 0x02, 0x7b, 0x03, 0x52, 0x12, 0x62, 0xb6, 0xe6, 0x0d, 0xe1, 0x32, 0x01, 0x1e, 0x9a, 0x17, + 0xd9, 0x47, 0xee, 0xe1, 0x51, 0x2e, 0x0d, 0xd8, 0x7a, 0xfe, 0x09, 0x9c, 0x11, 0xfd, 0xca, 0x58, + 0xbf, 0x9e, 0x66, 0x51, 0x3b, 0x3e, 0x1d, 0x2d, 0x2a, 0xdf, 0x88, 0xba, 0x13, 0x46, 0xdc, 0xe2, + 0x60, 0x7d, 0xb3, 0x0c, 0x6d, 0xd2, 0xec, 0xf2, 0x7a, 0x71, 0xfa, 0x88, 0xc5, 0x26, 0xb5, 0x8e, + 0xec, 0xb8, 0xe1, 0xe0, 0x30, 0x02, 0x32, 0xc9, 0xaa, 0x22, 0x3f, 0xd0, 0x79, 0xca, 0x02, 0xa8, + 0x38, 0x06, 0xde, 0x03, 0x39, 0x28, 0xba, 0x30, 0x85, 0xcf, 0xc4, 0xac, 0x1c, 0xef, 0xd4, 0x89, + 0x86, 0x84, 0x86, 0x74, 0x92, 0xd0, 0xc0, 0x80, 0xfb, 0x4b, 0xe7, 0x03, 0x2d, 0xc0, 0xae, 0x37, + 0x18, 0x0f, 0x00, 0x61, 0x2a, 0xfb, 0xe5, 0x0a, 0xc9, 0x53, 0x46, 0x5d, 0x91, 0xfe, 0xad, 0x6e, + 0xac, 0x9f, 0x7f, 0x5c, 0x2d, 0x3f, 0xae, 0x6c, 0xd8, 0x9b, 0x8d, 0xfa, 0x8e, 0xbd, 0x5d, 0x7f, + 0xf8, 0xf0, 0x29, 0x8e, 0x2e, 0x0f, 0x6c, 0xe4, 0x7c, 0x39, 0x92, 0xe4, 0x0d, 0xa0, 0x18, 0x78, + 0x27, 0x26, 0xe1, 0xf8, 0xbd, 0xf3, 0xb8, 0x11, 0x03, 0x1c, 0x84, 0xcb, 0x70, 0xc5, 0x4b, 0xd6, + 0xbf, 0x9e, 0x13, 0x73, 0x72, 0x64, 0xd8, 0x94, 0xf8, 0xd8, 0x70, 0xbe, 0x91, 0xe2, 0xdd, 0x52, + 0xa3, 0xf5, 0x14, 0x8e, 0x1a, 0x28, 0x94, 0x59, 0x8c, 0xea, 0xa8, 0x1c, 0x32, 0x51, 0x79, 0x52, + 0x4c, 0x7d, 0x5e, 0x6a, 0xda, 0x1b, 0xd5, 0xe6, 0xc3, 0x52, 0x0d, 0x09, 0x54, 0x26, 0x7f, 0x53, + 0x5c, 0xa3, 0x72, 0x7a, 0xf7, 0xb0, 0x53, 0x7a, 0x5c, 0xb1, 0x4b, 0xdb, 0x8d, 0x4a, 0x69, 0xe3, + 0x29, 0x97, 0xe4, 0xb2, 0x20, 0x13, 0x5c, 0x9f, 0xd0, 0x62, 0xb3, 0x5a, 0xdb, 0xa8, 0xd6, 0xb6, + 0x72, 0xc8, 0xfa, 0x5d, 0x88, 0xb4, 0xd9, 0xdc, 0xdb, 0xde, 0xce, 0xcd, 0xe6, 0x5f, 0x12, 0x57, + 0xa2, 0x15, 0x40, 0x35, 0xed, 0xd2, 0xc6, 0x46, 0x6e, 0x2e, 0xff, 0xaa, 0xb8, 0x31, 0xa1, 0x52, + 0xf9, 0xc8, 0xe5, 0xe6, 0x01, 0x0b, 0xbd, 0x92, 0xd0, 0x08, 0x56, 0xc7, 0xa5, 0x95, 0x9d, 0x87, + 0x95, 0x46, 0x0e, 0x3d, 0x15, 0x5e, 0x9a, 0x30, 0x4b, 0xa4, 0x61, 0x39, 0x91, 0x7f, 0x45, 0xbc, + 0x9c, 0xf4, 0xb1, 0xad, 0x4a, 0x4b, 0xee, 0xdc, 0x22, 0x70, 0xcc, 0x17, 0x55, 0x2d, 0x2c, 0x0b, + 0xb7, 0x09, 0xc9, 0xfb, 0x46, 0x6e, 0x09, 0x20, 0x67, 0xb9, 0x5a, 0x7b, 0x52, 0x6d, 0x55, 0xec, + 0x8d, 0x4a, 0xad, 0x0a, 0x45, 0x48, 0x5b, 0x04, 0xf5, 0xe3, 0x95, 0xae, 0xe0, 0xef, 0x9d, 0x12, + 0x50, 0xca, 0xd2, 0xc6, 0x4e, 0xb5, 0x96, 0x3b, 0x87, 0xc7, 0x50, 0xab, 0xe0, 0x34, 0xeb, 0xf6, + 0xee, 0x5e, 0xa3, 0xfc, 0xa8, 0xd4, 0xac, 0xe4, 0x72, 0xc8, 0x0f, 0x34, 0xab, 0x5b, 0x40, 0x4d, + 0x61, 0xe6, 0xcd, 0x66, 0x69, 0xab, 0x92, 0x3b, 0x0f, 0x00, 0xb1, 0xb4, 0xb5, 0x57, 0xdd, 0xde, + 0xb0, 0xf9, 0xd8, 0xa0, 0xd1, 0x75, 0x51, 0x30, 0x27, 0xd2, 0xa8, 0x6c, 0xa1, 0xdf, 0x60, 0x7d, + 0x73, 0x73, 0xbb, 0x5a, 0xab, 0xe4, 0x2e, 0xe0, 0x44, 0x5b, 0xf5, 0x3a, 0x2c, 0xa5, 0x26, 0x8f, + 0x69, 0xab, 0x51, 0xdf, 0xdb, 0x6d, 0xe6, 0x2e, 0x02, 0xc6, 0xba, 0xda, 0xaa, 0xef, 0x35, 0x6a, + 0xb0, 0xe6, 0x5a, 0x8b, 0x96, 0x4e, 0x1c, 0xc9, 0x66, 0x7d, 0xaf, 0xb6, 0x91, 0xbb, 0x44, 0xa7, + 0x1d, 0xa9, 0x86, 0x89, 0x31, 0x44, 0xd9, 0xd5, 0x8d, 0xdc, 0xe5, 0x49, 0x2d, 0xf8, 0x59, 0x0c, + 0xb4, 0xb8, 0x92, 0xbf, 0x2d, 0x5e, 0x4d, 0x6a, 0x51, 0xab, 0xdb, 0x8d, 0xd2, 0x46, 0xb5, 0x04, + 0x65, 0x04, 0x72, 0xab, 0xf9, 0x5b, 0xe2, 0xe6, 0x84, 0x86, 0x1b, 0xc0, 0x09, 0x71, 0xab, 0xab, + 0x74, 0xbe, 0x91, 0x56, 0xcd, 0xcf, 0xb6, 0xed, 0xbd, 0xdd, 0x8d, 0x52, 0x4b, 0x9d, 0x75, 0xae, + 0x40, 0xdb, 0x09, 0x0b, 0xd9, 0xae, 0x94, 0xb6, 0xf6, 0xd4, 0x26, 0xbf, 0x04, 0x78, 0xe1, 0x12, + 0x1f, 0x02, 0xd6, 0xd1, 0x4b, 0x1d, 0xdc, 0xef, 0x9d, 0x9d, 0xdc, 0x35, 0xfc, 0x7a, 0x62, 0x95, + 0x5d, 0xae, 0x97, 0xca, 0x8f, 0xca, 0xb0, 0x21, 0xad, 0xdc, 0xcb, 0xb8, 0x5c, 0x6e, 0xc5, 0x80, + 0x64, 0x57, 0x6b, 0x76, 0x09, 0x3a, 0x3c, 0x82, 0x3f, 0x09, 0x6e, 0xae, 0x27, 0xb5, 0xd8, 0xae, + 0x7f, 0x6e, 0xef, 0x36, 0xaa, 0xf5, 0x46, 0x15, 0xc0, 0xe6, 0x06, 0x5e, 0xad, 0xf2, 0x76, 0x15, + 0x67, 0x5f, 0xdf, 0x83, 0xff, 0x36, 0x6d, 0x9c, 0x79, 0xee, 0x26, 0x9e, 0x45, 0xb9, 0xbe, 0xb3, + 0x5b, 0x69, 0x55, 0x5b, 0xd5, 0x27, 0x15, 0xfc, 0x34, 0x2c, 0x9d, 0xbe, 0x5e, 0x69, 0xe6, 0x5e, + 0xc1, 0x7b, 0x15, 0xaf, 0x0e, 0x0d, 0x6d, 0x21, 0x54, 0xc7, 0xda, 0xb4, 0xec, 0xbd, 0xda, 0x76, + 0x9d, 0x20, 0xe5, 0xd5, 0xfc, 0x1b, 0xe2, 0x56, 0xa4, 0x01, 0xed, 0xa0, 0xe4, 0xd9, 0x5a, 0x70, + 0x09, 0x60, 0x44, 0x68, 0x79, 0x2b, 0x5f, 0x10, 0x97, 0xc3, 0x55, 0x7a, 0x94, 0xd7, 0x10, 0x93, + 0x34, 0x4b, 0xd0, 0x9d, 0x1a, 0x00, 0xef, 0xda, 0xd8, 0xdb, 0x6d, 0xe5, 0x5e, 0xc7, 0x5b, 0x5d, + 0xad, 0x35, 0xf7, 0x50, 0x0f, 0x4e, 0xcb, 0x03, 0x58, 0xac, 0xb7, 0x9a, 0xb9, 0xdb, 0xc9, 0x2b, + 0x7b, 0xb7, 0xd9, 0x2a, 0x95, 0x1f, 0x37, 0x73, 0x6f, 0x00, 0x47, 0x78, 0x27, 0x52, 0x2d, 0x77, + 0x70, 0xa7, 0x61, 0x37, 0x77, 0xf1, 0x56, 0xda, 0x08, 0xbe, 0xdb, 0xa5, 0x06, 0xc0, 0xff, 0x1d, + 0xe0, 0xf7, 0xdf, 0x4b, 0x58, 0x64, 0xa5, 0x56, 0xdf, 0xdb, 0x7a, 0x64, 0x37, 0x1f, 0x57, 0xb7, + 0xb7, 0x71, 0x47, 0x4b, 0x36, 0xb1, 0xd1, 0x3b, 0xf5, 0x86, 0x7a, 0x26, 0x96, 0xbb, 0x9b, 0xbf, + 0x2f, 0xee, 0x9d, 0xa9, 0x2b, 0x1c, 0x1a, 0x5f, 0xf2, 0x37, 0x71, 0xee, 0x3c, 0x1b, 0x00, 0xa5, + 0x0d, 0x38, 0x4f, 0x34, 0x35, 0xc0, 0x35, 0x65, 0xa4, 0xfa, 0x16, 0x6e, 0x05, 0x8c, 0x72, 0xff, + 0xc9, 0x7d, 0x5c, 0x12, 0x36, 0xac, 0xc2, 0x61, 0xdd, 0xc3, 0xdd, 0x0b, 0x8a, 0x43, 0x87, 0x54, + 0xcc, 0xdf, 0x11, 0xaf, 0x7d, 0x5e, 0xa9, 0x3c, 0xae, 0xd4, 0x70, 0x59, 0x00, 0xc9, 0x95, 0xa7, + 0x74, 0x63, 0x9b, 0xad, 0x46, 0xa9, 0x85, 0xf7, 0x16, 0xa7, 0x54, 0xdf, 0xad, 0xd4, 0x72, 0x6f, + 0xe3, 0xc7, 0xa3, 0x4d, 0xf7, 0x6a, 0x74, 0xb7, 0xe0, 0x1c, 0xde, 0xc1, 0x8f, 0xef, 0xd6, 0x9b, + 0x2d, 0x79, 0xdb, 0x9a, 0x7b, 0x8d, 0x27, 0x95, 0xa7, 0xb9, 0xfb, 0x88, 0x34, 0x5a, 0x8d, 0xfa, + 0xee, 0x23, 0x90, 0x39, 0x3e, 0x2f, 0x91, 0x60, 0xb1, 0x06, 0xa4, 0xe5, 0x9c, 0x2c, 0xdb, 0xae, + 0x3c, 0xa9, 0xe0, 0x7d, 0xc9, 0x3d, 0x40, 0x70, 0x81, 0x03, 0xb7, 0x01, 0x7a, 0x01, 0xd0, 0x1e, + 0xc1, 0x9f, 0x95, 0xda, 0x56, 0x05, 0xa6, 0x5a, 0xdf, 0x6a, 0x00, 0xb6, 0xc9, 0xbd, 0x8b, 0xa0, + 0x4a, 0x48, 0xa9, 0x5a, 0x83, 0x0d, 0x2b, 0x6d, 0xf3, 0x16, 0xe5, 0xde, 0xc3, 0x8e, 0xf1, 0xf2, + 0x60, 0xd7, 0xde, 0xc7, 0xf5, 0xb7, 0xf0, 0xb8, 0x70, 0x73, 0xb7, 0x60, 0xc3, 0xec, 0x9d, 0x6a, + 0x93, 0x09, 0xc4, 0x07, 0x78, 0x35, 0x9f, 0x94, 0xca, 0x7c, 0xcf, 0x2a, 0x8d, 0xea, 0x26, 0xe2, + 0xc7, 0x6f, 0xe2, 0xfd, 0x33, 0xc9, 0xd0, 0x67, 0x7b, 0x15, 0xb8, 0xb7, 0x30, 0x55, 0x80, 0x23, + 0x00, 0x14, 0xd8, 0x57, 0x20, 0x1c, 0x1f, 0xe2, 0x25, 0x98, 0xd4, 0xaa, 0xc2, 0xc4, 0x65, 0x1d, + 0x2f, 0x39, 0x97, 0x44, 0xb7, 0xfe, 0x5b, 0xb8, 0x9f, 0x3b, 0x3b, 0xaa, 0xd0, 0xae, 0xd7, 0xb6, + 0x9f, 0x4a, 0xd8, 0xb0, 0x4b, 0x8d, 0xdc, 0xb7, 0x71, 0xd6, 0xe5, 0xda, 0xd3, 0xb5, 0x77, 0xee, + 0xbf, 0x07, 0x75, 0x65, 0xd8, 0x09, 0x38, 0xef, 0x06, 0xa1, 0xc2, 0x8f, 0x10, 0x5f, 0x33, 0xda, + 0x23, 0xfc, 0xfd, 0x31, 0x02, 0x3b, 0x7f, 0x65, 0x17, 0x00, 0xa2, 0xd5, 0xb4, 0x2b, 0x25, 0x38, + 0x9e, 0x8d, 0xdc, 0x27, 0x48, 0x38, 0xca, 0x7b, 0xcd, 0x56, 0x5d, 0x5e, 0xad, 0x6a, 0x0d, 0x2f, + 0x48, 0xa5, 0xdc, 0x52, 0xfe, 0xdc, 0xb9, 0xef, 0x24, 0x5c, 0x65, 0x04, 0x75, 0x84, 0xf1, 0x47, + 0x55, 0x04, 0xc4, 0xb5, 0x5c, 0x09, 0xcf, 0x76, 0xbb, 0xba, 0x03, 0x24, 0x64, 0xc3, 0xde, 0x6b, + 0xc2, 0x3c, 0xe0, 0x7c, 0x5a, 0xb9, 0x87, 0xb8, 0xf3, 0xf2, 0xb3, 0x8d, 0xca, 0x4e, 0x75, 0x6f, + 0x27, 0xf2, 0xf9, 0xb2, 0xf5, 0x84, 0xbd, 0x3d, 0x90, 0xdf, 0x40, 0xf7, 0x2f, 0xf6, 0xa7, 0x69, + 0x6e, 0xd4, 0x13, 0x05, 0x22, 0x7c, 0x0a, 0xc0, 0x2c, 0xa3, 0x7a, 0x81, 0x07, 0xdc, 0xf9, 0x60, + 0xe8, 0x1d, 0xb8, 0xbd, 0x40, 0xd0, 0x60, 0x26, 0xe7, 0xdb, 0x81, 0x4c, 0x89, 0xe3, 0x96, 0xba, + 0xc0, 0x12, 0x9f, 0x79, 0x58, 0xeb, 0x23, 0xc0, 0x79, 0xb1, 0x59, 0x4d, 0x52, 0x6c, 0x92, 0x78, + 0xf0, 0x7d, 0x0f, 0x5f, 0x01, 0x32, 0x3f, 0x67, 0xfd, 0x56, 0x56, 0x2c, 0x99, 0xfd, 0x01, 0x5a, + 0xb4, 0x6f, 0x57, 0x4a, 0xbd, 0x5e, 0x8a, 0x8f, 0x6f, 0x70, 0xc4, 0xe9, 0x90, 0xea, 0x21, 0xa3, + 0x6c, 0x4b, 0xa8, 0x21, 0xce, 0x2a, 0x36, 0xab, 0x8d, 0x6b, 0x0a, 0x44, 0x2b, 0xd4, 0xcb, 0xb9, + 0xe4, 0xdb, 0x82, 0xc6, 0xad, 0x6e, 0xf0, 0xe6, 0xaf, 0xeb, 0xfa, 0xf8, 0xd8, 0xc2, 0x61, 0xf3, + 0xd3, 0x3c, 0x8e, 0x4a, 0x5e, 0xee, 0x5a, 0x47, 0xda, 0xf3, 0x48, 0x0b, 0xb4, 0xa0, 0xbe, 0x49, + 0x6a, 0x33, 0x16, 0x33, 0x5e, 0x15, 0x2f, 0x75, 0xda, 0x3d, 0x77, 0x9f, 0xe5, 0x6b, 0x29, 0x23, + 0x04, 0x3c, 0xea, 0xaa, 0xea, 0x42, 0x22, 0xdb, 0xa2, 0x7a, 0x6b, 0x41, 0x4f, 0x7d, 0xa9, 0x68, + 0x49, 0x49, 0x24, 0xfb, 0xa8, 0x27, 0x19, 0x72, 0xe1, 0xb2, 0x32, 0x02, 0x11, 0xc3, 0xec, 0xc9, + 0xd2, 0x15, 0x55, 0x1a, 0x52, 0xa4, 0x9c, 0x53, 0x4b, 0x1f, 0x0f, 0x7b, 0xf2, 0xd5, 0x20, 0x9c, + 0xf9, 0xc1, 0xb8, 0xd7, 0xa3, 0xb9, 0x90, 0x90, 0xd3, 0x95, 0xda, 0x51, 0xd8, 0x3f, 0x16, 0x4e, + 0x7c, 0x90, 0x28, 0x32, 0x7c, 0x38, 0x66, 0x2b, 0x56, 0x91, 0xde, 0x12, 0xd7, 0x8c, 0x42, 0x7c, + 0x21, 0xd1, 0xe1, 0x47, 0x28, 0x43, 0x8f, 0x4c, 0x4c, 0x17, 0x95, 0xaa, 0x98, 0x1e, 0x48, 0x23, + 0x67, 0x7d, 0xdc, 0x7e, 0x06, 0x8b, 0x35, 0x47, 0xba, 0xa4, 0x2c, 0x22, 0x28, 0x15, 0x72, 0x19, + 0x56, 0x93, 0x56, 0xe2, 0xb2, 0xf6, 0x4e, 0x87, 0x3a, 0x18, 0x57, 0x95, 0x93, 0x4a, 0xd5, 0xfa, + 0xdd, 0x54, 0x00, 0x5a, 0x6c, 0x86, 0x24, 0x00, 0x51, 0x27, 0x9d, 0x32, 0x4f, 0x9a, 0x19, 0x6a, + 0xb5, 0xbb, 0x99, 0xf8, 0xee, 0x66, 0x93, 0x76, 0x77, 0x26, 0x71, 0x77, 0x67, 0x13, 0x77, 0x77, + 0xce, 0xdc, 0xdd, 0x79, 0x52, 0x08, 0xfd, 0x7e, 0x36, 0x10, 0xa4, 0x83, 0x09, 0x6a, 0x71, 0xe9, + 0x81, 0x98, 0x53, 0xb2, 0x0b, 0x42, 0xb2, 0x29, 0xef, 0xc5, 0x5b, 0x17, 0xd9, 0xea, 0x1d, 0x07, + 0x6c, 0x94, 0x5e, 0x9d, 0x8e, 0xd7, 0xef, 0x9a, 0xc0, 0x94, 0x51, 0x1b, 0x27, 0x7d, 0x18, 0xbb, + 0xfc, 0xe8, 0x43, 0xde, 0xa9, 0x5f, 0xcd, 0x88, 0x59, 0x39, 0xdc, 0x45, 0x31, 0x27, 0x1f, 0x2e, + 0xe7, 0xfe, 0x51, 0xfd, 0x2f, 0x05, 0xab, 0x98, 0x93, 0xb6, 0x74, 0x10, 0x1e, 0x00, 0xfd, 0x21, + 0xcb, 0x65, 0x57, 0x76, 0x76, 0x49, 0x6a, 0x00, 0xf4, 0x47, 0xbf, 0x1f, 0x02, 0x71, 0x06, 0xd4, + 0xd4, 0x28, 0x95, 0x5b, 0x80, 0xde, 0x40, 0x70, 0x50, 0x0d, 0x5b, 0xc0, 0x32, 0xd7, 0x40, 0x60, + 0x00, 0x56, 0x98, 0x7f, 0x23, 0x05, 0xaf, 0x03, 0x82, 0xce, 0xe6, 0x97, 0xc5, 0x42, 0xab, 0xb4, + 0x25, 0x87, 0x9a, 0x21, 0x51, 0x03, 0x7e, 0x46, 0x46, 0x9a, 0x55, 0xcd, 0x78, 0x20, 0x94, 0xe6, + 0x97, 0xe8, 0xa7, 0x1a, 0x07, 0x8d, 0xaa, 0x4b, 0x65, 0xe0, 0x0e, 0x5a, 0xf5, 0x86, 0xfd, 0x70, + 0xaf, 0xf9, 0x34, 0x87, 0xd6, 0x9f, 0xf3, 0x7b, 0xb5, 0xe6, 0x6e, 0xa5, 0x4c, 0x54, 0xc5, 0xae, + 0x34, 0x1a, 0xf5, 0x06, 0xf0, 0xf2, 0xc0, 0x1f, 0xab, 0x86, 0xc4, 0xd3, 0x13, 0x62, 0x05, 0xa2, + 0x5b, 0x22, 0x3a, 0xba, 0x88, 0x2b, 0x25, 0x5a, 0xb1, 0x55, 0x07, 0xde, 0x1d, 0x91, 0xb3, 0xd9, + 0x98, 0x7e, 0xd0, 0x3b, 0x9c, 0x7a, 0x7d, 0x7b, 0xa3, 0xfe, 0x79, 0x2d, 0x87, 0x7b, 0x9a, 0xc7, + 0xd6, 0x40, 0x45, 0xb7, 0xeb, 0x30, 0x6d, 0xc9, 0x75, 0xae, 0x20, 0x7d, 0xa1, 0xc5, 0xc2, 0x3a, + 0x80, 0x92, 0x32, 0xdb, 0x02, 0xb8, 0x1f, 0xf0, 0xf5, 0xf6, 0x53, 0xe0, 0xf1, 0x8d, 0x79, 0x84, + 0x18, 0x25, 0x22, 0xc9, 0xb9, 0x9c, 0xf5, 0x87, 0x29, 0x91, 0x53, 0x87, 0x5f, 0xe9, 0xba, 0xa3, + 0x7f, 0x5a, 0x90, 0x6c, 0x42, 0x1d, 0xab, 0x88, 0xfc, 0x80, 0x26, 0xa8, 0xe9, 0x6e, 0xc3, 0x88, + 0x7a, 0x5e, 0xa9, 0xf8, 0xbc, 0xd2, 0x49, 0xf3, 0xca, 0x24, 0xce, 0x8b, 0x97, 0x60, 0x7c, 0x94, + 0xbd, 0x21, 0xfe, 0x44, 0xfa, 0xf5, 0x47, 0xbf, 0xaa, 0x6f, 0xd4, 0x7b, 0xd1, 0x1b, 0x15, 0xa8, + 0xbc, 0x93, 0xda, 0xcb, 0x3b, 0x65, 0xb5, 0xbf, 0xca, 0x75, 0x38, 0x33, 0xe8, 0x99, 0xa0, 0x65, + 0xed, 0xb0, 0x33, 0xb8, 0x39, 0x13, 0xe5, 0xe7, 0x93, 0xac, 0xef, 0x96, 0xdb, 0x9f, 0x8e, 0x6e, + 0x3f, 0x93, 0xe4, 0xff, 0x38, 0xc5, 0xaf, 0x70, 0x13, 0xc6, 0x33, 0x1d, 0xa4, 0xc2, 0x9b, 0x71, + 0xbb, 0x78, 0x4a, 0x17, 0xb5, 0x1f, 0xad, 0x9f, 0xc4, 0x7e, 0x58, 0xaf, 0xb3, 0xe7, 0x08, 0x7e, + 0x7f, 0x83, 0xc9, 0x28, 0x01, 0x79, 0xcc, 0xa7, 0xfd, 0x3f, 0x4c, 0xf1, 0x93, 0xc4, 0x48, 0x43, + 0xbd, 0xae, 0x6f, 0x47, 0xbc, 0x83, 0x5e, 0x2d, 0x4e, 0x69, 0x2d, 0x97, 0xb4, 0xae, 0x26, 0x8c, + 0x20, 0x19, 0x28, 0x4c, 0xd3, 0xf2, 0x65, 0x82, 0x5a, 0x6e, 0x68, 0x61, 0xf0, 0x03, 0x6f, 0xf7, + 0x5e, 0xa3, 0x92, 0x43, 0x27, 0xf4, 0xf3, 0xf2, 0x07, 0xcb, 0x0d, 0x84, 0xc0, 0xd2, 0xd6, 0xd5, + 0xe0, 0x58, 0xa5, 0x06, 0x8b, 0xb6, 0x15, 0x63, 0x38, 0xfc, 0xbe, 0x71, 0x44, 0x91, 0x3a, 0xbd, + 0x94, 0xef, 0x44, 0x96, 0x72, 0xbb, 0x78, 0x4a, 0x8f, 0xd8, 0x72, 0x6e, 0xc8, 0xe7, 0x32, 0xac, + 0x4f, 0x3b, 0x1f, 0x62, 0x85, 0x68, 0x1a, 0xd6, 0xe9, 0x8b, 0x03, 0xc6, 0x31, 0x17, 0xed, 0x87, + 0xc7, 0x02, 0x4c, 0x8a, 0x36, 0xf9, 0xcc, 0x93, 0x6b, 0xa6, 0xc1, 0x1e, 0x4a, 0xef, 0x96, 0x97, + 0xa4, 0xa3, 0x13, 0x07, 0x87, 0x58, 0x0e, 0x7d, 0xdf, 0xba, 0x17, 0x90, 0x3f, 0xfc, 0xbd, 0xcb, + 0xdd, 0x0d, 0x47, 0xdc, 0xf0, 0xc1, 0xbf, 0xcb, 0xde, 0x38, 0x61, 0x4e, 0x2e, 0xd2, 0x29, 0xfe, + 0x7c, 0xf6, 0xcd, 0x00, 0x5a, 0xb0, 0x57, 0x75, 0xe3, 0xe1, 0x49, 0x8d, 0x1e, 0xcf, 0x72, 0x87, + 0x10, 0x0e, 0xb5, 0xbe, 0x13, 0x20, 0x90, 0x70, 0x63, 0x79, 0x20, 0x30, 0x27, 0xc7, 0x38, 0x91, + 0xe5, 0x18, 0xb9, 0xb5, 0x1e, 0x87, 0x3f, 0xa7, 0xa7, 0x37, 0x69, 0x00, 0xb5, 0x41, 0xe9, 0xa4, + 0x0d, 0xba, 0x66, 0xd8, 0x77, 0x86, 0x1e, 0xa1, 0xa7, 0xc0, 0x25, 0xd8, 0xfa, 0x9f, 0x8c, 0x8b, + 0x10, 0xaa, 0xd6, 0xd8, 0x6e, 0x06, 0x87, 0x56, 0x7c, 0x70, 0xa0, 0x4c, 0x4d, 0x68, 0x5c, 0xc4, + 0x02, 0xf6, 0x34, 0x35, 0xa6, 0x48, 0x4b, 0x2a, 0x9c, 0x00, 0xb5, 0x35, 0x6b, 0x43, 0xa7, 0x12, + 0x26, 0x3b, 0x51, 0xc6, 0x38, 0x13, 0x62, 0x5a, 0xb3, 0x89, 0xe4, 0x64, 0x26, 0xd1, 0x43, 0x95, + 0x58, 0x6a, 0xab, 0x12, 0xe8, 0x94, 0xe9, 0x3c, 0xfa, 0xcf, 0xdd, 0x91, 0x63, 0xf3, 0xff, 0x0d, + 0xf1, 0x9d, 0xf9, 0x24, 0x63, 0x4e, 0xf8, 0x50, 0x7e, 0x31, 0x23, 0xde, 0x4e, 0x18, 0x67, 0xab, + 0x5c, 0x3d, 0x3e, 0x76, 0xba, 0x2e, 0x4c, 0x55, 0xed, 0x43, 0xcb, 0x93, 0x83, 0xe7, 0x77, 0x23, + 0x77, 0xef, 0x83, 0xe2, 0x57, 0x1c, 0x21, 0x76, 0x17, 0x61, 0x89, 0x2e, 0x55, 0x85, 0x1e, 0x47, + 0xc7, 0x99, 0x30, 0x46, 0xe1, 0xff, 0x6d, 0x2a, 0xf9, 0x66, 0x02, 0x3e, 0x95, 0xfa, 0x23, 0xe2, + 0x55, 0x00, 0xf7, 0x80, 0x54, 0xcb, 0x2a, 0x45, 0xa9, 0xa8, 0xd1, 0xd6, 0xc4, 0x34, 0x36, 0x56, + 0x55, 0x84, 0x7c, 0x33, 0x28, 0x25, 0xaa, 0x12, 0xa5, 0xd6, 0x04, 0x06, 0xa6, 0xf5, 0x48, 0x6a, + 0xd1, 0xd0, 0x56, 0xf3, 0x4a, 0x52, 0x03, 0xa5, 0x24, 0xc4, 0x56, 0xcd, 0xdc, 0x4c, 0x32, 0x12, + 0x9f, 0x45, 0x3e, 0x46, 0xf5, 0x4e, 0xe0, 0x63, 0xe6, 0xac, 0xe7, 0xec, 0xef, 0x1e, 0xdb, 0x46, + 0x85, 0xcf, 0xe4, 0xe6, 0x39, 0xc8, 0xf0, 0xf3, 0x66, 0x85, 0x9c, 0x93, 0xf5, 0xab, 0xfc, 0x08, + 0x8e, 0xd6, 0x72, 0x25, 0x82, 0x62, 0x26, 0xc4, 0x01, 0x11, 0xd0, 0x61, 0x64, 0x9c, 0xd7, 0x27, + 0x42, 0x92, 0x71, 0x76, 0x00, 0x51, 0x1b, 0x91, 0x83, 0x2f, 0x16, 0xcf, 0xd6, 0x51, 0x9d, 0x77, + 0x16, 0xf5, 0x40, 0x80, 0x76, 0xd4, 0xe9, 0xcd, 0x0b, 0x2a, 0x61, 0x33, 0x4a, 0xa3, 0xf2, 0x29, + 0x08, 0xfc, 0x39, 0xa2, 0x91, 0xad, 0xea, 0x4e, 0xa5, 0xbe, 0xd7, 0x02, 0x32, 0xf1, 0xd7, 0xc9, + 0xb3, 0xc3, 0x6d, 0x89, 0x82, 0xe5, 0xe6, 0x59, 0x66, 0x97, 0xd0, 0x51, 0xcd, 0x6e, 0x96, 0xb5, + 0x54, 0xc9, 0xc0, 0x68, 0x6d, 0xe9, 0x59, 0xc3, 0x5c, 0xb9, 0x25, 0xcc, 0x1b, 0xd8, 0x6d, 0x9e, + 0x37, 0xea, 0x28, 0xc2, 0x53, 0x4f, 0x86, 0x83, 0x0c, 0x52, 0xb7, 0xb3, 0xad, 0xc8, 0xc9, 0x6f, + 0x7d, 0xbd, 0x15, 0x9d, 0x89, 0x74, 0x9f, 0x85, 0xba, 0x7d, 0x18, 0x56, 0x8b, 0xd4, 0xfb, 0x12, + 0x67, 0xc7, 0x51, 0x1d, 0x62, 0x46, 0x72, 0x1e, 0xef, 0xca, 0xd8, 0x1c, 0x1f, 0x05, 0x66, 0x49, + 0x7c, 0x08, 0x78, 0x8a, 0xfe, 0x22, 0x86, 0x96, 0xfe, 0xb5, 0x54, 0x80, 0xde, 0xc2, 0xfd, 0x35, + 0x0e, 0xff, 0x24, 0xb2, 0x39, 0x01, 0x12, 0x4f, 0xee, 0x10, 0xdd, 0x94, 0x33, 0xed, 0xc0, 0xa7, + 0xfc, 0xce, 0x94, 0x76, 0x60, 0xd8, 0xee, 0xfb, 0x07, 0x80, 0x5b, 0x95, 0x22, 0x07, 0x1d, 0xde, + 0xfb, 0xce, 0x0b, 0x9b, 0x35, 0x20, 0xa7, 0xaf, 0xe9, 0x7f, 0x4b, 0xb1, 0x73, 0x7e, 0xe2, 0x60, + 0x7a, 0x59, 0x0f, 0x23, 0xcb, 0xba, 0x53, 0x3c, 0xb5, 0xcf, 0xd9, 0xd0, 0xa9, 0x75, 0x98, 0xbc, + 0x5e, 0x00, 0x61, 0xc2, 0x8d, 0xa4, 0xed, 0x4f, 0xa1, 0xe8, 0x89, 0x66, 0x10, 0xd2, 0xce, 0x4b, + 0xb3, 0x16, 0x88, 0xad, 0x54, 0x8b, 0x6a, 0x77, 0xa3, 0x22, 0x93, 0x0c, 0xe1, 0x59, 0xeb, 0x16, + 0xfb, 0x90, 0xd3, 0x43, 0x7b, 0x74, 0x1f, 0x4b, 0x66, 0x56, 0x7f, 0x25, 0x15, 0xec, 0xad, 0x6e, + 0xa6, 0xb7, 0x61, 0x3d, 0xb2, 0x0d, 0x81, 0x17, 0x61, 0xac, 0xed, 0x8f, 0x0b, 0xda, 0xd7, 0x82, + 0xf9, 0x3c, 0x74, 0xf0, 0x09, 0xfa, 0x70, 0xe4, 0x76, 0xdc, 0x01, 0xe9, 0x9c, 0x38, 0x6e, 0x56, + 0xc7, 0xf1, 0x7d, 0x7b, 0xe8, 0x1e, 0x1e, 0x8d, 0x7c, 0xb9, 0x88, 0x17, 0x01, 0x17, 0x4b, 0x2e, + 0xf9, 0x47, 0xed, 0x91, 0xe9, 0x8c, 0xc3, 0x7f, 0x9a, 0xd8, 0x78, 0x33, 0x28, 0x25, 0x63, 0x68, + 0x56, 0x9a, 0x3b, 0x49, 0x75, 0x11, 0xf4, 0xc6, 0x87, 0xf4, 0xb6, 0x74, 0xd4, 0x37, 0x8b, 0xf8, + 0x21, 0x41, 0xbb, 0x67, 0x15, 0xd9, 0x37, 0x5b, 0x6f, 0x88, 0xf9, 0x65, 0xb8, 0x61, 0xea, 0x1b, + 0xca, 0xe7, 0xc6, 0xfa, 0x20, 0x58, 0x1c, 0x3f, 0x52, 0xa8, 0x1e, 0xf6, 0x3d, 0x20, 0xac, 0x7b, + 0x3e, 0x5c, 0x49, 0xa4, 0x28, 0xfc, 0x33, 0x06, 0xc6, 0xd6, 0x0f, 0x67, 0x02, 0xe1, 0x03, 0x3f, + 0xb2, 0xc3, 0x91, 0xf3, 0x12, 0xaf, 0x71, 0xf8, 0xc3, 0x69, 0xc5, 0xd3, 0x0c, 0x9c, 0xa1, 0x0f, + 0x93, 0x36, 0x5d, 0x36, 0x96, 0x90, 0xb7, 0xfb, 0x72, 0x24, 0xd5, 0x88, 0x78, 0x60, 0xa1, 0x27, + 0x6f, 0xcb, 0xf9, 0x57, 0xc4, 0x55, 0x7f, 0x7c, 0x78, 0x48, 0x76, 0x6b, 0xc6, 0x73, 0xc6, 0xd7, + 0x66, 0x55, 0x40, 0x8d, 0x48, 0x13, 0xe3, 0xdd, 0xcd, 0xeb, 0xe2, 0xba, 0x8c, 0xfc, 0x67, 0x77, + 0x87, 0xed, 0x83, 0x91, 0xed, 0xbd, 0xe8, 0x87, 0x09, 0x26, 0x2b, 0x1e, 0x6f, 0x8b, 0x1b, 0xe1, + 0x76, 0xf1, 0x68, 0x4b, 0x0b, 0x4a, 0x3d, 0xeb, 0x3c, 0x97, 0xcf, 0x68, 0x85, 0x76, 0xe6, 0x0b, + 0x7f, 0x7f, 0xe4, 0xf1, 0x63, 0x15, 0x19, 0xe7, 0x04, 0x96, 0xce, 0x5d, 0x06, 0x00, 0x1a, 0x23, + 0x5f, 0x3a, 0x6b, 0xc2, 0x62, 0x3b, 0xf0, 0xdb, 0x3e, 0xe8, 0xb9, 0x03, 0xf9, 0xbc, 0xf4, 0x92, + 0x58, 0x90, 0x9f, 0x85, 0xc1, 0x51, 0x03, 0x39, 0xb3, 0x9e, 0xbe, 0x77, 0x3f, 0x7f, 0x53, 0xac, + 0xfa, 0x47, 0x18, 0x45, 0x4e, 0x49, 0x0f, 0x31, 0x47, 0x08, 0x7c, 0x76, 0x24, 0x37, 0x7c, 0xec, + 0x73, 0x77, 0x76, 0x87, 0x78, 0x07, 0x15, 0xae, 0x1d, 0xc7, 0x1e, 0x7a, 0xd2, 0x25, 0xc2, 0x74, + 0x9d, 0x35, 0x8e, 0xb1, 0xb8, 0x01, 0xad, 0x1a, 0x9e, 0x0c, 0x5a, 0xc5, 0x1f, 0x53, 0x5e, 0x84, + 0x79, 0xe5, 0xa7, 0xcd, 0xe5, 0xfa, 0x8d, 0xd5, 0x05, 0x2a, 0xb7, 0x44, 0xc1, 0x2c, 0x4f, 0xf2, + 0x99, 0xa0, 0x13, 0x32, 0xda, 0xe0, 0x5b, 0x25, 0x7c, 0xe3, 0x70, 0x29, 0x78, 0xf6, 0xce, 0xf1, + 0xe6, 0x30, 0xba, 0x89, 0x6d, 0x40, 0xce, 0x65, 0xa5, 0x13, 0x96, 0x6e, 0xa7, 0xa4, 0xb4, 0x2c, + 0x7c, 0x2c, 0xe6, 0xf5, 0x6c, 0xe1, 0x34, 0x70, 0x69, 0xe4, 0xb7, 0x92, 0x52, 0xe1, 0x0d, 0xb8, + 0xa4, 0xfd, 0xa5, 0x0c, 0x78, 0xb0, 0xa2, 0x51, 0x08, 0xc2, 0xdc, 0x8c, 0xe5, 0x18, 0x3a, 0x4f, + 0xda, 0x01, 0x22, 0x47, 0x31, 0xb1, 0x28, 0x06, 0xb1, 0x69, 0xfd, 0xc2, 0x2b, 0xb2, 0xd5, 0x99, + 0xc8, 0x34, 0x59, 0x45, 0xf8, 0x7f, 0xcc, 0x04, 0xd2, 0x6b, 0x04, 0x27, 0x68, 0xec, 0x86, 0x93, + 0x95, 0x7f, 0xcb, 0xab, 0x93, 0x8c, 0x2d, 0xc2, 0x17, 0x2a, 0xa3, 0x9c, 0x91, 0xf0, 0x45, 0x99, + 0xd2, 0xe4, 0x67, 0xa5, 0x3a, 0x39, 0xf2, 0x6c, 0xfb, 0x42, 0x31, 0x61, 0xad, 0x51, 0xe4, 0x33, + 0xfb, 0xf5, 0x90, 0x4f, 0xbe, 0xa2, 0x77, 0x76, 0x2e, 0x22, 0x7c, 0x4f, 0x58, 0xb0, 0x42, 0xd1, + 0x4b, 0xf4, 0xe6, 0x48, 0xe1, 0xe9, 0xab, 0xe2, 0xfc, 0x61, 0xc7, 0xe6, 0x27, 0x22, 0xe8, 0x0c, + 0x8d, 0xd6, 0x0b, 0x0e, 0x95, 0x96, 0xb4, 0xdb, 0x0b, 0x0a, 0xe2, 0x5f, 0x38, 0xbd, 0x8e, 0x87, + 0x6e, 0x4c, 0x0c, 0xc2, 0xfc, 0x16, 0xdc, 0xfa, 0x7f, 0xd3, 0x1a, 0xc5, 0x03, 0x6b, 0x6f, 0x7e, + 0x07, 0xf0, 0xfc, 0xaa, 0xb8, 0x28, 0x95, 0x31, 0xa4, 0x65, 0xac, 0x55, 0xb6, 0x29, 0x14, 0x26, + 0x6b, 0x27, 0x4a, 0x65, 0x32, 0x54, 0x1b, 0x36, 0x7c, 0x52, 0xc8, 0x96, 0xca, 0x8f, 0x94, 0x8e, + 0x32, 0x83, 0x3a, 0x4a, 0x32, 0x28, 0x55, 0x0d, 0x7e, 0x5f, 0x8e, 0xd4, 0xcc, 0x65, 0xc9, 0x35, + 0x11, 0x2d, 0xe9, 0xac, 0x23, 0xad, 0x7c, 0xb7, 0x5c, 0xa9, 0xa0, 0x05, 0x71, 0x86, 0x54, 0x3c, + 0xf2, 0x83, 0x81, 0xb3, 0x86, 0x59, 0x62, 0xd7, 0x9f, 0x54, 0x1a, 0x9b, 0x6c, 0x3f, 0x9e, 0x43, + 0x15, 0xa9, 0x72, 0xbc, 0xa8, 0x93, 0x8b, 0x06, 0x7e, 0x34, 0x87, 0xef, 0xe6, 0x2f, 0x99, 0xf3, + 0x0e, 0xbc, 0x26, 0x30, 0xba, 0x44, 0x61, 0xb7, 0x51, 0x7d, 0x82, 0x5f, 0x47, 0x6b, 0x17, 0x6b, + 0x5e, 0xb5, 0x4d, 0x5f, 0xc4, 0xea, 0xd1, 0xe2, 0x5a, 0x69, 0xec, 0x54, 0x9b, 0x64, 0x56, 0x5b, + 0x44, 0xff, 0x90, 0xa4, 0xfe, 0x68, 0xb6, 0x56, 0x83, 0x2c, 0xe1, 0xfa, 0x42, 0x8d, 0xa4, 0x13, + 0xc5, 0xb2, 0xf5, 0x94, 0x5f, 0x26, 0x47, 0x00, 0x68, 0x73, 0xdc, 0xeb, 0xed, 0x51, 0xe4, 0xc4, + 0x04, 0x5a, 0x34, 0x6b, 0x02, 0x6b, 0x7a, 0x22, 0xb0, 0x86, 0x58, 0xc0, 0xfa, 0xe8, 0xc8, 0x19, + 0x7e, 0x4a, 0xc6, 0xad, 0xe9, 0x84, 0x6e, 0xd2, 0xed, 0x8d, 0x07, 0x3f, 0x49, 0x80, 0xb0, 0x6c, + 0xe4, 0x3e, 0xb3, 0xea, 0xf4, 0x7b, 0x81, 0xe2, 0x83, 0xa6, 0xb1, 0xed, 0x1c, 0x8c, 0x4e, 0x9b, + 0x84, 0xf9, 0xb9, 0xf4, 0xa4, 0xcf, 0xb1, 0x30, 0xfb, 0xff, 0x19, 0xca, 0x2e, 0x63, 0x58, 0xde, + 0x84, 0x29, 0x9b, 0x48, 0x81, 0x87, 0x80, 0x5e, 0xf9, 0x21, 0xa3, 0xe1, 0x2c, 0xdc, 0xcd, 0x15, + 0xb6, 0x02, 0x6a, 0x0c, 0xc1, 0x5e, 0xbd, 0xf7, 0x8a, 0xa7, 0x7c, 0xa5, 0xc8, 0xfb, 0xcb, 0x45, + 0x05, 0x1b, 0xee, 0x90, 0xf1, 0xfb, 0xc7, 0x8f, 0x26, 0x6f, 0xc6, 0x7c, 0xe2, 0x8c, 0x79, 0xa1, + 0xfe, 0xc5, 0xfa, 0x7f, 0x0c, 0x41, 0x29, 0xb9, 0x89, 0xc6, 0xa7, 0x15, 0x31, 0xaf, 0x5f, 0x9d, + 0xb0, 0x4a, 0xe7, 0x41, 0xf1, 0x6c, 0x5d, 0x8b, 0x46, 0x79, 0xe1, 0xe7, 0x31, 0x48, 0xec, 0x14, + 0x16, 0x4e, 0xfb, 0x53, 0x63, 0xc8, 0xc8, 0x00, 0x84, 0x71, 0x79, 0x51, 0xd4, 0x9a, 0xf9, 0x9a, + 0x7c, 0xdd, 0xbd, 0x80, 0xa1, 0xc4, 0x6e, 0x5b, 0xce, 0x08, 0x39, 0x34, 0x8a, 0x99, 0x90, 0x00, + 0x05, 0xd6, 0x5f, 0x46, 0xa0, 0xc7, 0x68, 0x6f, 0x46, 0xef, 0x8b, 0x41, 0xcf, 0x37, 0xa3, 0x57, + 0xf0, 0x76, 0xf1, 0x94, 0x61, 0x8a, 0x12, 0x30, 0x9e, 0x8a, 0xd9, 0x9f, 0x14, 0x48, 0xfc, 0xc0, + 0xb0, 0xf9, 0xf1, 0x24, 0xf8, 0x4b, 0x65, 0x64, 0x7a, 0x26, 0x1c, 0x46, 0x74, 0xdf, 0xd3, 0x5f, + 0x73, 0xdf, 0x7f, 0x4b, 0x46, 0x48, 0x4d, 0xfe, 0xb8, 0xde, 0xcb, 0x9f, 0xe8, 0x24, 0x62, 0x9a, + 0x3e, 0xc6, 0x10, 0xff, 0x43, 0x2a, 0xbc, 0x2f, 0xdc, 0xdc, 0xaf, 0xb0, 0xbc, 0x8d, 0xcc, 0x3b, + 0x8b, 0xde, 0x76, 0xbb, 0xd7, 0x93, 0x8f, 0x8a, 0x55, 0xb4, 0x8e, 0x6f, 0x89, 0x73, 0x52, 0x2c, + 0xd7, 0x15, 0x7c, 0xdc, 0x56, 0x71, 0xf2, 0x88, 0x45, 0xfe, 0x59, 0xd8, 0x47, 0x82, 0x8a, 0x7f, + 0xd1, 0xbc, 0x80, 0x63, 0xed, 0x81, 0x28, 0x34, 0x1a, 0x4b, 0x3b, 0x0b, 0x45, 0xc2, 0x45, 0x46, + 0x44, 0x97, 0xa6, 0xd5, 0xfb, 0x12, 0x6a, 0xeb, 0xf5, 0x0f, 0xb9, 0x38, 0xa3, 0x8b, 0xb1, 0xb1, + 0x2e, 0xc6, 0x23, 0x4f, 0x5b, 0x7f, 0x92, 0x09, 0x14, 0xe8, 0x14, 0xb0, 0x01, 0xbd, 0x23, 0xcc, + 0x50, 0x30, 0x09, 0xaf, 0x1f, 0x94, 0x5e, 0x35, 0x93, 0xa8, 0x57, 0xcd, 0x86, 0xde, 0xf8, 0x04, + 0x5e, 0x07, 0x33, 0x21, 0x7d, 0xeb, 0x6c, 0xdc, 0xc8, 0x36, 0x97, 0x64, 0x64, 0x9b, 0xa7, 0xc2, + 0x3b, 0xc1, 0x6d, 0x59, 0xa0, 0xed, 0x5b, 0x2d, 0x46, 0x27, 0x2d, 0xaf, 0x47, 0xfe, 0xbe, 0x58, + 0x24, 0x61, 0x80, 0xa4, 0x46, 0x0c, 0x84, 0x18, 0x76, 0xd6, 0xd7, 0xcd, 0xab, 0xba, 0x11, 0x4a, + 0xc6, 0x8a, 0x95, 0x59, 0x54, 0x08, 0xc6, 0xed, 0xc3, 0x7a, 0xd0, 0x21, 0xba, 0xdd, 0xe3, 0x00, + 0x89, 0x85, 0x4f, 0xf4, 0xbd, 0x3b, 0x83, 0x03, 0x88, 0x76, 0xdc, 0x00, 0x96, 0x58, 0x3a, 0xdc, + 0x16, 0x6a, 0x42, 0x18, 0x1f, 0x4d, 0x1a, 0x44, 0x8a, 0x61, 0x36, 0x05, 0xbe, 0xd1, 0x26, 0xf2, + 0xa0, 0x19, 0x56, 0x74, 0x9d, 0xa1, 0x04, 0xcb, 0x5f, 0x4c, 0x07, 0xda, 0x21, 0x5a, 0x56, 0x69, + 0xdc, 0x75, 0x47, 0xc9, 0xe7, 0x77, 0x0f, 0xd5, 0x43, 0x23, 0xc3, 0x7d, 0x39, 0xb2, 0x23, 0xaa, + 0x6b, 0x91, 0x34, 0xe9, 0x85, 0x3f, 0x48, 0x89, 0x19, 0xd6, 0xa9, 0xc3, 0xba, 0xa4, 0xd4, 0x45, + 0x71, 0x78, 0x43, 0xf3, 0x64, 0x71, 0x31, 0xad, 0x50, 0x49, 0xbb, 0x63, 0x3c, 0xbe, 0xb8, 0x26, + 0x2e, 0x1a, 0xf3, 0x96, 0x1e, 0xd0, 0xde, 0x30, 0xf0, 0x74, 0x36, 0x6a, 0x47, 0xed, 0xe1, 0xa1, + 0x33, 0x92, 0x00, 0x82, 0x8f, 0x24, 0x55, 0xb0, 0x73, 0x72, 0x15, 0xb6, 0xdb, 0x52, 0xdc, 0x8c, + 0xd7, 0xec, 0xf3, 0x83, 0x3f, 0xeb, 0x3f, 0x4f, 0x07, 0xb8, 0xa3, 0xc4, 0xe3, 0xd2, 0xaa, 0xf8, + 0xbc, 0xfc, 0x23, 0x77, 0xe0, 0x4f, 0x72, 0xfa, 0x29, 0x03, 0x33, 0x1f, 0xb4, 0x92, 0x9b, 0x13, + 0xa8, 0xf9, 0x26, 0x8f, 0x56, 0x0c, 0x7e, 0xe2, 0x20, 0x26, 0xcc, 0x65, 0xce, 0x3e, 0x48, 0x00, + 0x10, 0x85, 0xb7, 0x84, 0x30, 0x86, 0x4c, 0xbc, 0x82, 0x04, 0x4c, 0x6c, 0xf8, 0xd8, 0x0e, 0x01, + 0x53, 0xbc, 0xf5, 0x57, 0x03, 0xa5, 0xe3, 0x00, 0xc1, 0xd1, 0x2c, 0xd9, 0x87, 0x23, 0xd1, 0x0e, + 0xf5, 0x63, 0xb0, 0xe5, 0x5b, 0x7f, 0x9a, 0x0e, 0xac, 0x43, 0xa1, 0xef, 0x05, 0xd2, 0x59, 0x64, + 0x39, 0x0f, 0xc4, 0xac, 0x33, 0x1c, 0x7a, 0x92, 0x5a, 0x9a, 0x86, 0xd3, 0x84, 0xfe, 0xc5, 0x4a, + 0x05, 0xdb, 0x92, 0x99, 0x82, 0xff, 0x84, 0x2b, 0xbe, 0x68, 0x28, 0xca, 0xbe, 0x8a, 0x67, 0x48, + 0xcc, 0x13, 0x24, 0x13, 0x71, 0x16, 0x39, 0xb3, 0x67, 0x48, 0xd4, 0x15, 0x64, 0x0e, 0x45, 0x11, + 0x25, 0xfb, 0x68, 0xa1, 0x86, 0x9c, 0xa4, 0x9b, 0xb9, 0xf9, 0x09, 0xde, 0x1a, 0x0b, 0xd6, 0x41, + 0x00, 0xeb, 0x8c, 0xcc, 0x9c, 0x91, 0x04, 0x30, 0x10, 0xcc, 0x4d, 0x63, 0x63, 0x64, 0x0b, 0x31, + 0x30, 0x3b, 0x5d, 0xb4, 0x78, 0x20, 0x6b, 0x44, 0x5e, 0x5c, 0x15, 0xa0, 0x2b, 0xeb, 0x37, 0xd2, + 0x1c, 0xba, 0x66, 0xe2, 0x87, 0x34, 0xeb, 0x17, 0x56, 0x14, 0xbe, 0x55, 0x3c, 0x43, 0xaf, 0x62, + 0x25, 0xaa, 0x0c, 0xfe, 0xbd, 0x94, 0x98, 0xab, 0x24, 0xa9, 0x08, 0x41, 0x40, 0x24, 0xbd, 0xa6, + 0x6d, 0x1e, 0x20, 0x1d, 0x18, 0x17, 0x87, 0xe5, 0xa9, 0x34, 0x39, 0x52, 0xaa, 0x0a, 0x56, 0x96, + 0xb2, 0x0f, 0x2c, 0x1c, 0xdc, 0x2b, 0xe2, 0x65, 0xae, 0x9a, 0xb4, 0xeb, 0x59, 0x74, 0x84, 0xe6, + 0x26, 0xec, 0xac, 0x1e, 0x38, 0xa0, 0x93, 0x5d, 0xab, 0x99, 0x9b, 0xb1, 0x76, 0x03, 0x25, 0x32, + 0x2d, 0x90, 0x55, 0xfe, 0x6a, 0x8d, 0x5f, 0x63, 0xfb, 0xad, 0xbf, 0x4b, 0x47, 0x8e, 0x34, 0x32, + 0xa4, 0xdc, 0xe8, 0xa8, 0xf1, 0xe7, 0xcd, 0xe2, 0xe9, 0x9d, 0xe2, 0xfb, 0xfc, 0xff, 0xff, 0xb8, + 0xf6, 0x39, 0xb6, 0x99, 0xca, 0x24, 0xc7, 0x46, 0x36, 0x14, 0xda, 0x2d, 0x71, 0x7d, 0x52, 0x13, + 0xde, 0x5f, 0x7e, 0x78, 0x31, 0xe1, 0x4c, 0x78, 0x1c, 0x34, 0xe8, 0x4d, 0x3a, 0x14, 0xd5, 0x62, + 0xf6, 0xf4, 0x93, 0x9d, 0xb3, 0xea, 0x81, 0x89, 0x9e, 0x71, 0x06, 0x86, 0x66, 0xe8, 0xf1, 0xae, + 0x7d, 0xad, 0x63, 0xfb, 0xa3, 0x54, 0x04, 0x12, 0xc2, 0x23, 0xca, 0x53, 0x2b, 0x47, 0x4e, 0xed, + 0x6e, 0xf1, 0xd4, 0x3e, 0xf1, 0x43, 0xdb, 0xfc, 0xf1, 0x9c, 0x99, 0xf5, 0x2c, 0x32, 0x63, 0x16, + 0x3c, 0xb5, 0x2b, 0xcd, 0xa4, 0x4d, 0x50, 0x58, 0x3e, 0x1d, 0xc7, 0xf2, 0x99, 0x24, 0x2c, 0xcf, + 0x76, 0xcd, 0x3f, 0x4e, 0x45, 0xc0, 0x3a, 0xf2, 0xb5, 0xb3, 0x81, 0x75, 0x62, 0xa7, 0x9f, 0xdc, + 0x0e, 0x81, 0x04, 0x7a, 0x47, 0x7f, 0xbf, 0x8c, 0xb6, 0x53, 0x9e, 0x40, 0x7d, 0xe0, 0xf4, 0x69, + 0x3e, 0x68, 0x95, 0x38, 0x31, 0xb6, 0x4a, 0x6b, 0x6b, 0xf5, 0xd3, 0x5a, 0xbd, 0x79, 0x69, 0xe5, + 0x1e, 0x2a, 0x65, 0x8a, 0x00, 0x82, 0x64, 0x8e, 0x90, 0xe8, 0xcb, 0x60, 0x8e, 0x36, 0xfa, 0x29, + 0x87, 0x86, 0x3f, 0x6d, 0x06, 0x72, 0xfb, 0x80, 0xd1, 0x42, 0xcf, 0x49, 0x7c, 0xaa, 0x8e, 0x2f, + 0xc7, 0xbd, 0x8e, 0xcb, 0x6f, 0x60, 0x53, 0x32, 0x42, 0x7f, 0x64, 0xac, 0x0d, 0x98, 0xf6, 0xd0, + 0x3b, 0xf9, 0xda, 0xcb, 0x01, 0xf9, 0xf8, 0xcd, 0x33, 0x8d, 0xc8, 0xd3, 0xb3, 0xaa, 0xc1, 0xad, + 0xa3, 0x0a, 0x20, 0x07, 0xba, 0xe5, 0x64, 0x80, 0x4b, 0x7a, 0x31, 0x6d, 0xfd, 0xa6, 0x71, 0xdf, + 0x12, 0xc6, 0x3a, 0xf5, 0xbe, 0x4d, 0xec, 0x13, 0x87, 0xa6, 0x7b, 0x5f, 0x09, 0x9a, 0xac, 0xf7, + 0x82, 0x89, 0xa1, 0xce, 0xe6, 0x8c, 0x9b, 0x6b, 0xfd, 0xb6, 0x71, 0x41, 0x92, 0xfa, 0x9d, 0x7a, + 0x41, 0x26, 0x77, 0xfa, 0x91, 0x97, 0xf4, 0x37, 0xa9, 0x40, 0xb1, 0x48, 0xc3, 0xe3, 0x77, 0xe4, + 0x27, 0x0e, 0x60, 0x3a, 0x47, 0x09, 0xa7, 0xf6, 0xb1, 0x58, 0xf2, 0xa0, 0x15, 0x19, 0x30, 0x02, + 0x49, 0xe3, 0x8d, 0xe2, 0xd4, 0x71, 0x8a, 0xba, 0xa0, 0xd0, 0x15, 0x0b, 0xfa, 0x47, 0x02, 0x2c, + 0x26, 0x5f, 0x24, 0x9d, 0x82, 0x27, 0xc1, 0xb9, 0x27, 0xf1, 0x7a, 0x15, 0x02, 0xc3, 0x9d, 0x3c, + 0x1a, 0x9a, 0x17, 0x79, 0x9c, 0xfd, 0x67, 0xa9, 0x40, 0xfb, 0x63, 0x10, 0x55, 0xf2, 0x2a, 0x03, + 0xf1, 0x83, 0xad, 0x4c, 0x5d, 0x34, 0x33, 0xd1, 0xd2, 0x83, 0xb8, 0xb3, 0x91, 0x3b, 0xaf, 0x23, + 0xa7, 0x1a, 0x16, 0x37, 0x7c, 0xfc, 0x4b, 0x65, 0x81, 0xf7, 0xbe, 0xc2, 0xab, 0x33, 0xca, 0x67, + 0x54, 0xba, 0x95, 0x48, 0x81, 0x47, 0x5b, 0x91, 0x87, 0xa6, 0x61, 0x2d, 0xaa, 0xa3, 0x20, 0x33, + 0x9a, 0xf5, 0x49, 0x84, 0x83, 0x67, 0x9c, 0xa1, 0x6c, 0x85, 0x86, 0x84, 0x9b, 0x52, 0xea, 0xd8, + 0xc8, 0xbd, 0xfe, 0x38, 0xd0, 0xb2, 0xd2, 0x00, 0xe8, 0x67, 0xc9, 0x0e, 0xa7, 0x67, 0xa2, 0x0a, + 0xd6, 0x7f, 0x15, 0x05, 0x98, 0x60, 0x80, 0x89, 0x5c, 0x7d, 0xe0, 0x41, 0x90, 0x8e, 0x78, 0x10, + 0x24, 0x8e, 0x10, 0x07, 0xea, 0xef, 0x4e, 0x00, 0x6a, 0x64, 0xda, 0x43, 0x88, 0x3d, 0x35, 0x81, + 0x9d, 0x9e, 0xe8, 0x24, 0xf2, 0x8a, 0xe9, 0x01, 0x89, 0x21, 0x36, 0x80, 0xf6, 0x48, 0x0f, 0x75, + 0xe5, 0xe3, 0xf6, 0xa7, 0xa9, 0x00, 0xb7, 0xc5, 0xdb, 0xe8, 0x34, 0x25, 0xd7, 0x51, 0x57, 0xa9, + 0xc3, 0x22, 0x0d, 0xb9, 0xa1, 0xe1, 0xef, 0x9e, 0x52, 0x51, 0x07, 0xb1, 0x9d, 0x0e, 0x93, 0x14, + 0x6f, 0x97, 0x56, 0x0f, 0x12, 0x12, 0xc7, 0xa3, 0xf7, 0xc4, 0x12, 0xec, 0x65, 0x9b, 0xd8, 0x58, + 0xdc, 0x86, 0x55, 0x7d, 0x3f, 0x1b, 0xc0, 0x4b, 0x73, 0xbc, 0x7f, 0xec, 0x8e, 0x38, 0x00, 0x01, + 0xaf, 0x23, 0x99, 0xeb, 0xd1, 0x76, 0x32, 0x1e, 0xcf, 0x3e, 0xe8, 0xb5, 0x0f, 0xfd, 0x20, 0x86, + 0x0f, 0x26, 0x89, 0x43, 0x61, 0x93, 0x7c, 0xe6, 0x2c, 0x27, 0x40, 0x6d, 0xf1, 0xf1, 0xf5, 0xee, + 0x7c, 0xe5, 0xef, 0x84, 0x4d, 0x8a, 0x18, 0x5e, 0xfb, 0xa5, 0xf0, 0x11, 0x90, 0xb6, 0x50, 0xb3, + 0x32, 0x93, 0xc7, 0xc7, 0x8c, 0x4c, 0xd7, 0x92, 0xbb, 0x9e, 0x3e, 0x37, 0xce, 0x46, 0xd0, 0x65, + 0x51, 0x3d, 0x14, 0x04, 0x94, 0x53, 0x5c, 0x75, 0x8e, 0x30, 0x7a, 0x84, 0xa1, 0x42, 0x0c, 0xe2, + 0x1a, 0xf7, 0x4e, 0x42, 0x61, 0x2e, 0xf1, 0x11, 0x8b, 0x37, 0x3c, 0x74, 0x9f, 0x07, 0x1d, 0xd8, + 0xe8, 0xf1, 0x79, 0xb0, 0x7f, 0xe8, 0x4d, 0xe3, 0x74, 0x31, 0x92, 0xf7, 0x4e, 0xf0, 0x0c, 0xe5, + 0xb3, 0xb1, 0x33, 0x76, 0x22, 0x59, 0xe7, 0x52, 0x67, 0xc8, 0x3a, 0x67, 0xdd, 0x8f, 0xa1, 0x3f, + 0x15, 0xbf, 0xde, 0x9f, 0x14, 0x32, 0xf5, 0xbb, 0x26, 0x9c, 0x87, 0xbb, 0x98, 0x97, 0x3b, 0xa2, + 0x8b, 0xb6, 0x84, 0xd0, 0xf1, 0xf4, 0x15, 0x2d, 0x58, 0xe1, 0x0c, 0x6c, 0xaa, 0x3b, 0x72, 0x5b, + 0xf4, 0x06, 0xfd, 0x73, 0x9c, 0x31, 0xc5, 0xd0, 0x8f, 0xe7, 0x8b, 0x09, 0x22, 0x8a, 0x26, 0x05, + 0xe4, 0x03, 0xf6, 0xe7, 0x85, 0x8c, 0xef, 0x15, 0xea, 0x95, 0x51, 0x66, 0xa0, 0x48, 0x8e, 0xb4, + 0x73, 0xe8, 0x59, 0xce, 0x8a, 0xd8, 0x19, 0x7a, 0xe3, 0x75, 0x49, 0xa6, 0x9b, 0x21, 0x3e, 0x5c, + 0xcf, 0xc3, 0xfa, 0x0b, 0x99, 0x90, 0x50, 0x97, 0xe8, 0x95, 0x7e, 0x2a, 0xce, 0xf3, 0x17, 0xc9, + 0xd4, 0x9e, 0xe0, 0x01, 0x15, 0xeb, 0x52, 0x34, 0x4b, 0x08, 0x7f, 0xed, 0xf2, 0xb3, 0x3f, 0x0a, + 0x6e, 0x44, 0xd9, 0xab, 0x30, 0x8b, 0xc8, 0x80, 0x72, 0x60, 0xd8, 0xed, 0x6e, 0x77, 0x28, 0x17, + 0x77, 0x5d, 0x5c, 0x36, 0xaa, 0xa5, 0xad, 0x9e, 0xea, 0x35, 0x54, 0x19, 0xf5, 0x18, 0xc1, 0x2e, + 0xab, 0x1c, 0x33, 0x68, 0x72, 0x91, 0x3d, 0x99, 0xa1, 0x3d, 0x99, 0xb4, 0x63, 0xb3, 0x54, 0xfb, + 0xaa, 0x78, 0x89, 0x6b, 0x61, 0xc4, 0x71, 0xdf, 0xfd, 0x82, 0xf2, 0x5a, 0x00, 0x55, 0x1d, 0x05, + 0xef, 0x2b, 0x66, 0xad, 0x3f, 0x48, 0x89, 0x73, 0x91, 0x35, 0x21, 0xfe, 0x95, 0xab, 0x02, 0xfc, + 0xbb, 0x20, 0x66, 0x48, 0xd0, 0x63, 0xbc, 0x8b, 0x2f, 0x0a, 0x9b, 0x95, 0xc6, 0x93, 0x4a, 0xa3, + 0x56, 0x6f, 0x29, 0x03, 0x2f, 0x69, 0x64, 0x02, 0x7f, 0xd0, 0x0c, 0x6a, 0x51, 0xca, 0xa5, 0x5a, + 0xb9, 0xb2, 0x8d, 0x78, 0x39, 0xcb, 0xcf, 0x72, 0xf1, 0xbd, 0x61, 0xa9, 0x55, 0x7d, 0x88, 0x2e, + 0x9a, 0xfc, 0x0c, 0x71, 0x86, 0x5e, 0x43, 0x22, 0x56, 0xaf, 0x6d, 0xf1, 0x33, 0xe9, 0xe6, 0xde, + 0xc3, 0x66, 0xb9, 0x51, 0xdd, 0x25, 0x0f, 0x40, 0xcc, 0xa9, 0xb0, 0x4c, 0x2f, 0x1e, 0xf5, 0xa7, + 0xe6, 0xac, 0x8f, 0xd8, 0xd2, 0x45, 0x7c, 0xc5, 0x36, 0xdd, 0x5b, 0x3d, 0xf9, 0x5d, 0xb8, 0x55, + 0x83, 0xd1, 0xd4, 0x0d, 0x03, 0xce, 0xe9, 0x2a, 0xa7, 0x6a, 0xa2, 0x7b, 0x15, 0x17, 0x96, 0x42, + 0xc1, 0x69, 0xb2, 0x08, 0xd3, 0x85, 0xa4, 0xf6, 0x12, 0x7c, 0x56, 0x42, 0xdc, 0x1c, 0x46, 0xdf, + 0x98, 0x09, 0x52, 0x6a, 0xc5, 0xa3, 0x39, 0x3c, 0x10, 0x59, 0x8c, 0x98, 0x27, 0xcd, 0x59, 0x1c, + 0xbf, 0x86, 0x6a, 0x9e, 0x40, 0xe9, 0xfa, 0xa5, 0xd0, 0x4f, 0x95, 0xc7, 0xd1, 0x7a, 0x9f, 0xf9, + 0xd1, 0x26, 0xad, 0x46, 0xe7, 0xfe, 0x8a, 0xcc, 0x3c, 0x21, 0x04, 0x4f, 0x85, 0x91, 0x0e, 0xf2, + 0xf5, 0xdc, 0x37, 0x71, 0x05, 0xa7, 0x45, 0xa0, 0xb0, 0xbe, 0x08, 0x5c, 0x0f, 0x23, 0x2e, 0xf0, + 0x49, 0x1a, 0x58, 0x42, 0xf4, 0x1c, 0x20, 0xa3, 0x1f, 0xe4, 0x07, 0xb9, 0xa7, 0x23, 0xd2, 0xa9, + 0x95, 0x57, 0x38, 0xcf, 0x5b, 0x85, 0x4a, 0xd7, 0x97, 0x9f, 0xd9, 0x00, 0x53, 0x36, 0x97, 0xdd, + 0xb7, 0xfe, 0x7c, 0x36, 0x60, 0xdc, 0xa2, 0x7e, 0xed, 0xd1, 0x1d, 0x7f, 0x5f, 0x1e, 0xb6, 0x9a, + 0x09, 0xe3, 0x15, 0xb9, 0xff, 0x57, 0x8b, 0xe5, 0x66, 0x5d, 0x65, 0x36, 0x92, 0xca, 0x14, 0xf6, + 0xd7, 0x02, 0x12, 0xbd, 0xd2, 0x83, 0x0b, 0xa8, 0x22, 0xc5, 0x38, 0x4a, 0xd1, 0x1b, 0x3f, 0xb2, + 0x59, 0x0c, 0xfb, 0xe2, 0x70, 0xc6, 0xad, 0x45, 0x43, 0x57, 0x19, 0x99, 0x19, 0x07, 0x0b, 0xea, + 0x62, 0xc8, 0xc2, 0x68, 0xec, 0xb3, 0x19, 0xed, 0x96, 0x15, 0x89, 0x90, 0x63, 0x3a, 0x13, 0xcf, + 0x85, 0x1a, 0x19, 0xe6, 0x92, 0x6f, 0x03, 0x1e, 0x3f, 0xf2, 0x5e, 0x74, 0x50, 0x4a, 0xc7, 0xa9, + 0x90, 0xeb, 0xc6, 0xe2, 0xda, 0x6b, 0x13, 0x27, 0xd2, 0x94, 0xad, 0x69, 0x2a, 0xeb, 0x14, 0x74, + 0x0e, 0x83, 0xbb, 0xa0, 0xbf, 0x90, 0xa3, 0x6c, 0x28, 0x93, 0x97, 0xc1, 0xc1, 0x84, 0x76, 0xa1, + 0x71, 0xfe, 0x5b, 0x62, 0x99, 0xcd, 0x05, 0x23, 0x8a, 0x60, 0x8a, 0x09, 0xa7, 0x32, 0xa1, 0xf0, + 0x5d, 0xd1, 0xbe, 0x14, 0xa5, 0x91, 0xc3, 0x9d, 0x9a, 0x1e, 0x8a, 0x4b, 0xd1, 0x10, 0xcb, 0x84, + 0xdd, 0xd8, 0x59, 0xeb, 0x23, 0xa0, 0xa5, 0x0e, 0xe5, 0x4c, 0x01, 0x56, 0x92, 0xe2, 0x1a, 0xad, + 0xd0, 0x47, 0x26, 0x2f, 0x6f, 0x53, 0x36, 0xaf, 0x42, 0x6b, 0x24, 0xb9, 0x6d, 0xce, 0x3a, 0x86, + 0xa1, 0xef, 0x3a, 0x8e, 0x4c, 0x4f, 0xb9, 0x5c, 0x78, 0x53, 0x08, 0xe3, 0x40, 0x62, 0x89, 0x00, + 0xd5, 0x7b, 0x59, 0xd6, 0xbf, 0xbf, 0x2b, 0x96, 0x42, 0x9b, 0x16, 0x6b, 0x0e, 0x07, 0xea, 0xed, + 0x7f, 0xdf, 0xe9, 0xc8, 0x18, 0x28, 0x48, 0xff, 0x96, 0x0a, 0x40, 0xaf, 0x8d, 0xcd, 0x4a, 0x88, + 0xbe, 0x84, 0x61, 0x53, 0x30, 0x54, 0x61, 0xd7, 0x39, 0x90, 0x1f, 0xba, 0x21, 0x16, 0xcd, 0x3d, + 0x32, 0xbd, 0xe0, 0xa8, 0x4b, 0xe1, 0x91, 0x58, 0x0a, 0xad, 0x0f, 0xc5, 0x08, 0x1c, 0xc2, 0x8c, + 0x56, 0x1e, 0x9e, 0x09, 0x66, 0xa7, 0xc1, 0x10, 0x5a, 0x3d, 0x4f, 0x99, 0x75, 0xb4, 0x41, 0x29, + 0x7a, 0x71, 0xf9, 0xab, 0x7e, 0xec, 0x0e, 0x85, 0x2f, 0x32, 0x53, 0xab, 0x0f, 0xa3, 0x70, 0x93, + 0x89, 0x58, 0x3a, 0xc3, 0x63, 0x9a, 0x60, 0xb3, 0x1e, 0x05, 0x9b, 0x09, 0x37, 0x47, 0x75, 0x35, + 0x76, 0xe4, 0x27, 0xb1, 0xa7, 0x20, 0xd0, 0x47, 0x12, 0x45, 0x6e, 0x39, 0xa3, 0xc8, 0x8e, 0x24, + 0x25, 0x54, 0x79, 0x5b, 0x51, 0x8a, 0xe6, 0x28, 0xfe, 0x66, 0x28, 0xa9, 0xc3, 0x03, 0x46, 0xd4, + 0x89, 0x1d, 0x26, 0xe1, 0x2f, 0xeb, 0xb5, 0x40, 0x2f, 0x4f, 0xc9, 0x53, 0x6a, 0xde, 0xc8, 0x3d, + 0x38, 0x69, 0x8e, 0xc9, 0x3b, 0xf6, 0x60, 0xdc, 0x63, 0x6e, 0xd6, 0xfa, 0x9f, 0xe7, 0xc4, 0x39, + 0xd5, 0xee, 0x73, 0xf6, 0xd8, 0x8a, 0xa4, 0x95, 0x20, 0xbf, 0x69, 0x3a, 0xfb, 0x79, 0x64, 0x35, + 0x8c, 0x1a, 0x23, 0x32, 0x1d, 0xb1, 0x14, 0xe4, 0x0f, 0x86, 0xf6, 0x3b, 0x87, 0x6e, 0x9c, 0x0d, + 0xb7, 0xf2, 0x48, 0xda, 0xeb, 0x6e, 0x88, 0x2b, 0x28, 0x79, 0xf3, 0xeb, 0xe7, 0x0e, 0x4e, 0xb8, + 0x33, 0x46, 0xa9, 0xa3, 0x77, 0x22, 0xa5, 0xd8, 0xd7, 0xc4, 0xcb, 0x1c, 0x0b, 0xfc, 0xc1, 0xb0, + 0x2b, 0x7d, 0x1b, 0x99, 0xee, 0x1c, 0x71, 0x68, 0x2e, 0xf9, 0x1c, 0xfd, 0x13, 0x71, 0x11, 0x2b, + 0x4d, 0x1f, 0x51, 0x1d, 0xeb, 0x6b, 0x65, 0xed, 0x42, 0x71, 0x97, 0x2b, 0x25, 0x4a, 0x26, 0xee, + 0x76, 0x09, 0xe3, 0x36, 0xd4, 0x2a, 0x0d, 0x8e, 0xdb, 0x76, 0x53, 0xac, 0x92, 0x0e, 0xb2, 0x6b, + 0xbf, 0xf0, 0x86, 0x9c, 0x81, 0x91, 0xff, 0xd2, 0xae, 0x6b, 0x98, 0x26, 0x28, 0xf2, 0x09, 0x8e, + 0xfe, 0xba, 0x18, 0x4a, 0x39, 0x4b, 0x8a, 0x04, 0xf9, 0xc2, 0x7b, 0x49, 0x71, 0xe9, 0x54, 0x03, + 0xcc, 0x3e, 0x72, 0x5f, 0xb0, 0xcd, 0x32, 0x74, 0x16, 0x70, 0x4b, 0xfe, 0xd1, 0x78, 0xd4, 0xf5, + 0x5e, 0xf4, 0x7b, 0xed, 0x17, 0xb0, 0x5b, 0xb0, 0xa1, 0x30, 0x20, 0xfc, 0x3b, 0xc6, 0x28, 0xb7, + 0xec, 0x23, 0x9a, 0x34, 0x31, 0xc5, 0xc4, 0xe6, 0xd4, 0xf8, 0xca, 0xc3, 0x54, 0x72, 0x79, 0xe4, + 0x32, 0x4a, 0x9a, 0x05, 0x7e, 0x95, 0xde, 0x39, 0x91, 0xd1, 0xb1, 0xe0, 0x76, 0xc3, 0x60, 0x87, + 0x76, 0xdf, 0x0b, 0xde, 0xb1, 0x03, 0xae, 0x1f, 0xf7, 0xb4, 0x91, 0x55, 0x39, 0xd0, 0x7a, 0x43, + 0x17, 0x28, 0x25, 0x39, 0x82, 0x52, 0xba, 0x2d, 0x8c, 0xd5, 0x0b, 0x02, 0x88, 0x0b, 0x92, 0xe1, + 0xb8, 0xdf, 0xf3, 0x3a, 0xcf, 0x38, 0xf5, 0x5d, 0x16, 0x4f, 0xf0, 0xb0, 0x63, 0xfb, 0x5e, 0x07, + 0xe4, 0x16, 0xc7, 0xa6, 0x59, 0xa8, 0xe9, 0x5d, 0x96, 0x29, 0x69, 0x2e, 0x42, 0xfb, 0x76, 0xcf, + 0xfd, 0x01, 0x3f, 0xff, 0xef, 0xba, 0xe8, 0x73, 0x8b, 0x5e, 0xa1, 0xe1, 0x4b, 0x2a, 0xa1, 0xac, + 0xb8, 0x6d, 0x34, 0xde, 0xa0, 0xb6, 0x08, 0x04, 0xae, 0x8f, 0xf8, 0xf6, 0x00, 0xf1, 0x10, 0xec, + 0x03, 0xea, 0x41, 0x70, 0xb2, 0xf2, 0x20, 0x28, 0x84, 0x00, 0x42, 0x21, 0x27, 0x47, 0x76, 0x6c, + 0xba, 0x90, 0xfe, 0xea, 0x55, 0xb2, 0xf6, 0xcd, 0x15, 0x2b, 0x1c, 0xcd, 0x77, 0x4d, 0xac, 0x38, + 0x5f, 0x8e, 0x86, 0x6d, 0xe5, 0x7a, 0xe8, 0xaf, 0x16, 0x54, 0x06, 0xdf, 0xc8, 0x1c, 0xca, 0x15, + 0x6c, 0x07, 0x85, 0x08, 0xd9, 0xc7, 0x18, 0x6e, 0x0f, 0xd6, 0x3d, 0x74, 0x3a, 0x74, 0xcd, 0x25, + 0x7a, 0xc4, 0x68, 0xa4, 0xd9, 0xc2, 0xaf, 0xa4, 0x44, 0x3e, 0x61, 0xc6, 0x24, 0xd1, 0xf6, 0xc9, + 0x47, 0x9a, 0x55, 0x26, 0x0f, 0x44, 0x01, 0x38, 0x12, 0x38, 0xbd, 0xa3, 0x20, 0x47, 0x14, 0x6d, + 0x96, 0x7f, 0xd4, 0xbe, 0x2f, 0xb9, 0x87, 0x73, 0x34, 0x8f, 0xe6, 0xa3, 0xd2, 0x7d, 0x39, 0xca, + 0x9a, 0xb8, 0x2a, 0xc5, 0x96, 0x84, 0x3e, 0x99, 0xc4, 0x3e, 0x85, 0x3b, 0xc0, 0x08, 0xeb, 0xd9, + 0x0b, 0x1d, 0x93, 0x8b, 0x10, 0x19, 0x4d, 0x09, 0x37, 0x86, 0xb0, 0xb8, 0xf5, 0x18, 0x84, 0xb9, + 0x80, 0x5d, 0x41, 0x42, 0xb4, 0xd9, 0x7e, 0x8e, 0x89, 0xe0, 0x40, 0x98, 0x5b, 0x8d, 0xe3, 0x1b, + 0x9d, 0x95, 0x28, 0x1c, 0x97, 0x8e, 0x8b, 0xad, 0x37, 0x03, 0xc9, 0x30, 0x34, 0x52, 0xa9, 0xdb, + 0x8d, 0x91, 0x37, 0xab, 0x18, 0x08, 0xde, 0xa1, 0xc6, 0x0d, 0xe7, 0xd8, 0x7b, 0xee, 0xc4, 0xdb, + 0xbf, 0xcd, 0x62, 0x56, 0xd3, 0x19, 0x85, 0xc8, 0x26, 0xdc, 0xb9, 0x10, 0xa7, 0x12, 0x74, 0x78, + 0x47, 0xe6, 0x11, 0x77, 0x46, 0x26, 0x75, 0xf3, 0x39, 0xe0, 0xab, 0x41, 0xfd, 0xb9, 0x07, 0x72, + 0xaf, 0x3f, 0x15, 0xb8, 0x43, 0x84, 0xbb, 0x24, 0x71, 0x9d, 0x49, 0xc3, 0xa4, 0x29, 0x20, 0x60, + 0x84, 0x5c, 0x22, 0x11, 0x5b, 0xb2, 0xae, 0xf0, 0xd8, 0x12, 0x35, 0x33, 0xbd, 0xc1, 0x58, 0x9c, + 0xd6, 0x7f, 0x8d, 0x81, 0x1c, 0x36, 0x4e, 0x00, 0x6f, 0xba, 0x1d, 0x2e, 0x56, 0x71, 0x47, 0x13, + 0x02, 0x2b, 0x06, 0x09, 0x74, 0xcd, 0xc8, 0x95, 0x18, 0x35, 0x7b, 0xe8, 0xfe, 0x00, 0xee, 0xbe, + 0xe7, 0xa1, 0x87, 0x96, 0xd2, 0x5e, 0xc2, 0x14, 0x91, 0xfb, 0xe9, 0xe1, 0x75, 0x50, 0x1c, 0x27, + 0x23, 0x63, 0x10, 0xe1, 0x5c, 0xca, 0xca, 0xaf, 0x2e, 0x34, 0x8b, 0x8e, 0x32, 0xcb, 0x42, 0xf8, + 0xae, 0x87, 0x33, 0xe3, 0x59, 0xa2, 0x60, 0xd4, 0x49, 0x68, 0xd2, 0x6d, 0xd8, 0x9b, 0xe2, 0x3f, + 0xcd, 0x88, 0xf3, 0x65, 0x8c, 0x03, 0x7a, 0xda, 0x8a, 0xc2, 0x4e, 0x41, 0x11, 0x65, 0x6b, 0x46, + 0x15, 0x4a, 0xc3, 0x50, 0x5f, 0xa5, 0x7c, 0x26, 0x0d, 0x26, 0x6e, 0x39, 0xd0, 0x63, 0x93, 0xd9, + 0x95, 0xaf, 0xc6, 0x75, 0x20, 0x48, 0x45, 0xb3, 0x25, 0x8b, 0x32, 0xa7, 0xa8, 0xcd, 0xd1, 0xb8, + 0x8b, 0xc1, 0xd6, 0xfb, 0x76, 0xa4, 0xc1, 0xbc, 0x12, 0x7d, 0x31, 0x1f, 0x28, 0xa5, 0xeb, 0x06, + 0xb1, 0xd5, 0xe9, 0xf3, 0x27, 0x16, 0x94, 0x23, 0x1c, 0x59, 0xae, 0x82, 0xed, 0x96, 0x2f, 0x09, + 0x90, 0x45, 0xc0, 0x3c, 0x90, 0xdf, 0xf7, 0x86, 0x41, 0x8a, 0x54, 0xca, 0x49, 0x0e, 0x18, 0x1b, + 0x68, 0xe0, 0x92, 0x5a, 0xef, 0xc8, 0x85, 0x5f, 0xcb, 0x4a, 0xf8, 0x6e, 0x63, 0x76, 0x9b, 0xb1, + 0xd6, 0x96, 0xac, 0x28, 0xcf, 0x0b, 0x6f, 0x78, 0xd8, 0xee, 0xc3, 0x27, 0x86, 0x32, 0x6e, 0x89, + 0x8e, 0x57, 0x8a, 0x3a, 0x59, 0x89, 0xf3, 0x91, 0xe9, 0xe8, 0x77, 0xb9, 0xe4, 0xbc, 0x0e, 0xf8, + 0x0e, 0x78, 0x68, 0xa4, 0x52, 0x4e, 0xd1, 0x7c, 0x75, 0x08, 0x5d, 0xdb, 0xa5, 0x30, 0xcb, 0x17, + 0xd4, 0x0e, 0xfa, 0x5f, 0x8c, 0xd1, 0xb1, 0x9f, 0x4b, 0x2f, 0x92, 0xce, 0xcd, 0x17, 0x8b, 0x65, + 0xe3, 0xc4, 0xee, 0x88, 0xa5, 0x2e, 0x03, 0xa6, 0xad, 0xd3, 0x12, 0x92, 0xab, 0x6f, 0x1c, 0x5c, + 0x6f, 0x8b, 0x45, 0x9f, 0x0e, 0x3c, 0x60, 0x11, 0x29, 0x09, 0x6e, 0x0c, 0x0a, 0x78, 0xa3, 0xf0, + 0x29, 0x07, 0x43, 0xe9, 0xbc, 0xf5, 0x31, 0xf3, 0x8c, 0x8a, 0x5b, 0x09, 0xae, 0x06, 0x7a, 0x19, + 0xab, 0x38, 0x2c, 0x3a, 0xda, 0x4d, 0xec, 0xd3, 0xe8, 0x65, 0x9c, 0x0f, 0xc9, 0x4f, 0x28, 0xc9, + 0xfa, 0x71, 0xb9, 0x1a, 0x24, 0xc2, 0x19, 0x8e, 0x1d, 0x9f, 0x4e, 0x0a, 0x92, 0x4b, 0xbd, 0x64, + 0xf4, 0x55, 0xfc, 0xbb, 0x50, 0x94, 0xdc, 0x3c, 0xfd, 0x9a, 0x14, 0xd1, 0x97, 0x44, 0x6b, 0xd6, + 0x7f, 0xff, 0x14, 0xbf, 0x99, 0x2a, 0xb7, 0x65, 0x24, 0x47, 0xea, 0x16, 0x9f, 0xc5, 0x03, 0xa3, + 0xd3, 0x99, 0xe5, 0xf1, 0x8f, 0x15, 0xf6, 0x40, 0x0f, 0xac, 0xe7, 0xce, 0xb4, 0xf1, 0x23, 0xae, + 0x67, 0x3c, 0xb7, 0x5f, 0x95, 0xc9, 0xb0, 0x74, 0x47, 0xc3, 0xb5, 0x34, 0xfc, 0x66, 0x7b, 0x3d, + 0xb5, 0xf6, 0xb5, 0xa6, 0x98, 0x10, 0xba, 0x3f, 0x33, 0x21, 0x74, 0x3f, 0xeb, 0x8f, 0xff, 0xd7, + 0x74, 0x70, 0x6c, 0x8f, 0x80, 0xbf, 0xab, 0x1f, 0x6c, 0xca, 0x14, 0x98, 0x2f, 0x1c, 0xe7, 0x99, + 0xdc, 0xe1, 0x6f, 0x1b, 0x48, 0x56, 0xc5, 0x21, 0x8d, 0xba, 0x3f, 0x06, 0x9d, 0xb5, 0x98, 0x26, + 0x63, 0xe1, 0x7e, 0x4b, 0x9c, 0xd3, 0xbd, 0x31, 0xf4, 0xb5, 0xf4, 0x56, 0x3a, 0xa5, 0xf3, 0x26, + 0xb5, 0x2c, 0x1c, 0x8a, 0x95, 0xc8, 0x70, 0x67, 0x0a, 0xad, 0x0b, 0x2c, 0xa2, 0x4e, 0xe8, 0x10, + 0x0a, 0xff, 0xce, 0x4e, 0x94, 0xa1, 0x64, 0xf5, 0xb4, 0x11, 0x85, 0xef, 0x05, 0x1f, 0xe2, 0x4f, + 0x9f, 0xed, 0x43, 0xd1, 0x88, 0xec, 0x3a, 0x1a, 0xac, 0x86, 0x07, 0x36, 0xa2, 0xdf, 0x09, 0x9e, + 0x8d, 0x05, 0x8b, 0x35, 0x1c, 0xb3, 0x82, 0xdd, 0xb6, 0x7e, 0x3a, 0x50, 0xe9, 0x9b, 0x4d, 0x25, + 0xa4, 0xdc, 0x41, 0x59, 0xba, 0xd7, 0xb3, 0xbd, 0x03, 0xd8, 0x4c, 0xe9, 0xcc, 0x65, 0x3a, 0xfe, + 0x1b, 0x87, 0x98, 0x8f, 0xbc, 0xb2, 0x07, 0xa0, 0x52, 0x2a, 0x25, 0xd5, 0xd2, 0x83, 0xef, 0xf6, + 0x31, 0xba, 0x6a, 0xb3, 0xe3, 0x0d, 0x9d, 0x40, 0xa5, 0x34, 0x33, 0x84, 0x75, 0xf3, 0xa2, 0xe9, + 0x09, 0x95, 0x35, 0x0c, 0xf4, 0xd8, 0x49, 0xfd, 0xe4, 0xe4, 0x96, 0xc5, 0x8c, 0x8f, 0x05, 0x67, + 0xd3, 0x89, 0x19, 0x51, 0x00, 0x32, 0x2a, 0xc0, 0x31, 0x7f, 0x37, 0x4b, 0xef, 0x8c, 0xde, 0x0f, + 0x3c, 0xdb, 0x9b, 0x28, 0xb3, 0xa0, 0x92, 0xcf, 0xdb, 0x45, 0x76, 0x51, 0x4d, 0x14, 0x76, 0x5f, + 0xd2, 0x3c, 0x8e, 0x3f, 0xcf, 0x1b, 0xf8, 0x9b, 0x86, 0x2f, 0x77, 0xac, 0xa3, 0x9c, 0xe9, 0x87, + 0x62, 0x66, 0x40, 0x8c, 0x67, 0xca, 0x48, 0x5a, 0x34, 0xa5, 0x43, 0x51, 0x17, 0x15, 0x3e, 0x14, + 0x0b, 0xfa, 0x07, 0x99, 0x37, 0xf1, 0x47, 0x00, 0x22, 0xb0, 0x88, 0x91, 0x3b, 0xea, 0x19, 0x3e, + 0xb6, 0x48, 0x0e, 0x89, 0x8c, 0x5a, 0x35, 0x9e, 0x18, 0xa3, 0xcd, 0x26, 0x70, 0x02, 0xdd, 0x71, + 0xcf, 0x79, 0x88, 0x4c, 0x3c, 0xbf, 0x43, 0x3e, 0xf0, 0xe2, 0x2f, 0x82, 0xc3, 0xd4, 0x39, 0xfc, + 0xe4, 0xfc, 0xd7, 0xa4, 0x9d, 0x33, 0x61, 0x40, 0x9c, 0xd9, 0x3e, 0xfe, 0x31, 0x2d, 0xdc, 0x36, + 0x19, 0x62, 0x0e, 0x40, 0xd6, 0xe9, 0x29, 0x96, 0x24, 0x6a, 0x00, 0xca, 0xbf, 0xad, 0x22, 0x3c, + 0x70, 0xb8, 0xec, 0x9b, 0xc5, 0x53, 0x16, 0x60, 0xd5, 0xc5, 0x8a, 0xf1, 0xa0, 0x72, 0x42, 0x74, + 0xea, 0xbb, 0x62, 0xde, 0x97, 0xbd, 0x25, 0x26, 0x59, 0x9d, 0x34, 0xb0, 0xb5, 0x16, 0x18, 0x24, + 0xc3, 0xd5, 0x86, 0x06, 0x34, 0x32, 0xbe, 0xb5, 0x17, 0x80, 0x4e, 0xb4, 0x8f, 0xd6, 0x7e, 0xaa, + 0xc8, 0xde, 0x29, 0x83, 0x7d, 0x37, 0x66, 0x9d, 0x74, 0x7b, 0xbe, 0x08, 0xae, 0x66, 0x78, 0x58, + 0x34, 0x71, 0x9e, 0xbe, 0xce, 0xd4, 0xb4, 0x75, 0x52, 0x88, 0x6d, 0x07, 0xb3, 0xb0, 0xd8, 0x74, + 0x6e, 0x92, 0x2e, 0x3f, 0x0d, 0x2e, 0x5e, 0xfc, 0x93, 0x3f, 0xda, 0x6a, 0x3e, 0x8d, 0x6e, 0xac, + 0x5f, 0xed, 0xef, 0x00, 0x2b, 0x79, 0xa4, 0x36, 0x16, 0x40, 0xf9, 0x18, 0x7f, 0x07, 0x90, 0x78, + 0xe2, 0xb4, 0x87, 0x81, 0x53, 0x34, 0x71, 0x51, 0x19, 0x19, 0x8c, 0xe9, 0xfa, 0xa4, 0xb1, 0xa6, + 0x90, 0x38, 0xfd, 0x81, 0x74, 0xe8, 0x03, 0x19, 0x29, 0x6f, 0x6b, 0xbe, 0x83, 0xd5, 0x48, 0xd1, + 0x45, 0x59, 0xff, 0x91, 0x54, 0xd1, 0x13, 0x3a, 0xd9, 0x02, 0xd4, 0x31, 0x60, 0x75, 0x37, 0x67, + 0xde, 0x05, 0xd8, 0x4e, 0xbb, 0x03, 0xba, 0xe0, 0x73, 0x0f, 0xd3, 0xb9, 0x14, 0xdc, 0x88, 0x2c, + 0xa9, 0x1f, 0xc9, 0xd5, 0x80, 0x4a, 0x6e, 0x8b, 0x1b, 0xed, 0xf1, 0xc8, 0x53, 0x69, 0xcc, 0x38, + 0x51, 0x37, 0x67, 0x8b, 0x93, 0x99, 0xea, 0x65, 0xd0, 0xe3, 0xcd, 0xd0, 0x0b, 0x8b, 0x15, 0x38, + 0xc5, 0x4a, 0xf2, 0x47, 0xd7, 0xaf, 0x3d, 0xb3, 0x27, 0x54, 0xd9, 0xf5, 0xc7, 0xd6, 0x98, 0x4d, + 0x70, 0x86, 0x01, 0xd0, 0x6c, 0xd6, 0xc6, 0x2c, 0x3c, 0xf9, 0xfb, 0xf8, 0x1c, 0x80, 0x0c, 0x53, + 0x58, 0xa5, 0xde, 0x21, 0xbe, 0x54, 0x9c, 0xb2, 0x52, 0x90, 0x8d, 0x43, 0x19, 0xe3, 0xd0, 0x46, + 0x6c, 0x07, 0x69, 0xd0, 0x4c, 0x2b, 0xb8, 0xf1, 0x69, 0xec, 0xac, 0x50, 0xa9, 0xf5, 0xcf, 0x0d, + 0x2b, 0x78, 0xbc, 0x8d, 0x3c, 0x43, 0xe0, 0xca, 0x69, 0x6a, 0x3c, 0x33, 0x2d, 0x6f, 0xa4, 0x94, + 0x4c, 0xc2, 0x39, 0x39, 0x68, 0xfb, 0x98, 0x4d, 0xb0, 0xf7, 0x4f, 0x78, 0x19, 0xd2, 0xbf, 0xe3, + 0xae, 0xb0, 0x26, 0xb7, 0xb1, 0xd9, 0x08, 0xb6, 0x06, 0x32, 0x42, 0x86, 0x52, 0xd1, 0x5f, 0x25, + 0x02, 0x2d, 0x6d, 0x39, 0xb4, 0x39, 0xba, 0xc9, 0xac, 0x91, 0xd8, 0x7b, 0xea, 0x6e, 0x52, 0xfe, + 0x77, 0xda, 0x9a, 0xae, 0xeb, 0xf3, 0x0b, 0x0e, 0x39, 0x7b, 0x35, 0x14, 0x3b, 0x5e, 0x6c, 0x06, + 0x97, 0x01, 0x64, 0x55, 0x33, 0xe6, 0x7c, 0x89, 0x14, 0x72, 0xa7, 0xeb, 0xbf, 0xd8, 0x53, 0xeb, + 0x5b, 0x41, 0xf4, 0x91, 0xc4, 0x71, 0xa6, 0xdd, 0x07, 0x6b, 0x3b, 0x38, 0x03, 0xd6, 0x06, 0x4a, + 0x35, 0xd9, 0x26, 0x9a, 0xce, 0xcb, 0x94, 0xbe, 0x04, 0xb1, 0x8c, 0x64, 0x4b, 0x34, 0x96, 0xe1, + 0x37, 0xf5, 0xc4, 0xa9, 0x18, 0x46, 0x76, 0xeb, 0xdd, 0x80, 0xe7, 0x68, 0x6a, 0xbd, 0xe7, 0x2e, + 0x2a, 0xa6, 0x3a, 0x27, 0x49, 0xba, 0x2a, 0x5e, 0xc0, 0xbb, 0x01, 0x87, 0x10, 0xeb, 0x35, 0x31, + 0xc6, 0x90, 0xf5, 0x6d, 0xe6, 0x6c, 0x65, 0x16, 0x11, 0x29, 0x3d, 0xa0, 0x1a, 0x3b, 0xce, 0x1a, + 0x87, 0xd0, 0x24, 0xcf, 0xf4, 0x06, 0x6f, 0x7e, 0xac, 0xb7, 0x76, 0x3f, 0x1b, 0xb1, 0x9a, 0x62, + 0xab, 0x4c, 0x16, 0xbf, 0x0d, 0xd4, 0xd3, 0x81, 0x74, 0xe8, 0x74, 0x39, 0xd9, 0x45, 0xc2, 0x47, + 0xca, 0x42, 0xbc, 0x08, 0x2c, 0xea, 0xcc, 0x42, 0x5f, 0xe2, 0xac, 0x11, 0x34, 0x04, 0x77, 0x24, + 0xf5, 0x23, 0x27, 0xf1, 0xfb, 0x9c, 0x2c, 0xec, 0x3a, 0x2f, 0x46, 0x63, 0xa7, 0xb4, 0x6d, 0x95, + 0x98, 0xba, 0xd2, 0x39, 0x0e, 0xb6, 0xa5, 0x4c, 0xc7, 0x99, 0x35, 0x28, 0x75, 0x28, 0x17, 0xa8, + 0x8f, 0xce, 0xf0, 0x8b, 0x74, 0xce, 0xa4, 0xa5, 0xc2, 0x77, 0x48, 0x0d, 0x74, 0xc2, 0x10, 0x53, + 0x01, 0x41, 0xeb, 0x29, 0xfc, 0x50, 0x47, 0x5f, 0x25, 0x08, 0x8f, 0x55, 0x4c, 0x1d, 0xed, 0x3d, + 0xd5, 0x89, 0x3c, 0xb5, 0xc2, 0x1a, 0xd8, 0x6d, 0xb7, 0x4f, 0xa4, 0x47, 0x69, 0x54, 0xb5, 0x07, + 0xc2, 0x8c, 0x3a, 0x15, 0xd6, 0x9e, 0xc3, 0x17, 0xbe, 0x1f, 0x7e, 0x93, 0xec, 0x5b, 0x45, 0xc3, + 0xf9, 0x04, 0x84, 0x60, 0x4e, 0x5f, 0xdb, 0x70, 0x3a, 0xc3, 0xb1, 0x3b, 0xf2, 0xf9, 0x6d, 0x36, + 0xff, 0x2d, 0x13, 0xca, 0xbe, 0x1b, 0xdc, 0xb1, 0x70, 0x5b, 0x45, 0x70, 0x60, 0x57, 0x4d, 0x9f, + 0x30, 0xee, 0xf5, 0x0b, 0x99, 0x80, 0xb6, 0x44, 0xbb, 0x9d, 0x1a, 0xc4, 0x2c, 0xb9, 0x43, 0xcc, + 0x03, 0x09, 0x1f, 0x3e, 0xea, 0xc9, 0xa6, 0x23, 0x0f, 0x1f, 0x27, 0x8c, 0x11, 0x2a, 0x96, 0x88, + 0x78, 0x0b, 0xb3, 0x04, 0x50, 0x41, 0xf0, 0x60, 0xf4, 0xeb, 0x0c, 0x54, 0xb0, 0xc5, 0x85, 0xa4, + 0xf1, 0x93, 0x64, 0x92, 0xe0, 0xf5, 0x5f, 0x3a, 0x48, 0x36, 0xf5, 0x1c, 0xce, 0xc7, 0x06, 0x4c, + 0xdb, 0xd7, 0x4e, 0x74, 0x40, 0x6b, 0xf7, 0xbd, 0xbe, 0xa4, 0x60, 0xf3, 0x5f, 0xd5, 0x8f, 0x70, + 0x97, 0xd3, 0xed, 0xc6, 0x56, 0xa1, 0xbd, 0xd5, 0x9d, 0xc1, 0x68, 0xc3, 0xe9, 0xf4, 0xdc, 0x3e, + 0xf1, 0xc4, 0x6d, 0x2a, 0x70, 0x94, 0x67, 0x5d, 0x82, 0x99, 0x49, 0x25, 0x96, 0x09, 0xa9, 0xe2, + 0x76, 0x51, 0xa1, 0xb3, 0xeb, 0x79, 0xbd, 0x24, 0x9e, 0xee, 0x31, 0x73, 0x42, 0xc9, 0x1d, 0x34, + 0x28, 0x24, 0x30, 0x61, 0x98, 0xb1, 0x20, 0xd0, 0x14, 0xa5, 0xcd, 0x9c, 0xf9, 0x64, 0x11, 0xa2, + 0x5c, 0x73, 0xa3, 0x76, 0x1f, 0xb5, 0x4d, 0xbe, 0xf5, 0x8f, 0x32, 0xc9, 0x44, 0xbc, 0x4a, 0x7f, + 0xe3, 0x03, 0xca, 0x9e, 0xc8, 0x85, 0x52, 0x80, 0x60, 0xcb, 0xe8, 0xe4, 0x3e, 0x45, 0x2c, 0x2d, + 0xfc, 0xfb, 0x69, 0x91, 0x3d, 0x83, 0x55, 0xd2, 0x88, 0xe2, 0x9b, 0x51, 0x2b, 0x80, 0x5a, 0x1b, + 0x03, 0xd0, 0xb6, 0x9f, 0x05, 0x2e, 0x47, 0xfb, 0xa8, 0x79, 0x37, 0x2a, 0x66, 0x94, 0xe2, 0xaa, + 0xfd, 0xfc, 0x50, 0xe6, 0xaa, 0x9a, 0x25, 0x79, 0x17, 0xf7, 0xff, 0xf9, 0xa1, 0x4a, 0x54, 0x35, + 0x47, 0x65, 0x78, 0xd7, 0xa0, 0x4c, 0xa5, 0x98, 0x99, 0xa7, 0x42, 0xcc, 0x39, 0x03, 0x85, 0x87, + 0x83, 0x63, 0x52, 0xb5, 0xe9, 0x82, 0x2f, 0xa1, 0x40, 0xa8, 0xa1, 0xe8, 0xb3, 0x3c, 0xfc, 0xa2, + 0x12, 0x82, 0xa9, 0x4c, 0x8d, 0xb5, 0xa4, 0x84, 0x60, 0x2a, 0xc5, 0xc1, 0x96, 0x43, 0x25, 0x38, + 0xda, 0x8a, 0x4e, 0x15, 0xe6, 0x0c, 0x0f, 0x30, 0xf1, 0x07, 0x26, 0x58, 0x3c, 0x47, 0x6f, 0x19, + 0xa5, 0x61, 0x6c, 0xab, 0x8c, 0x24, 0x00, 0xd9, 0x5c, 0x0f, 0x63, 0x0f, 0x01, 0x51, 0x57, 0xa8, + 0x8e, 0x39, 0x96, 0x8f, 0x15, 0x4d, 0x48, 0x6c, 0x46, 0xa1, 0x92, 0xb5, 0x52, 0x31, 0x41, 0x94, + 0xb2, 0x7e, 0x4a, 0xdc, 0x9a, 0xfe, 0x19, 0x79, 0xda, 0x6b, 0xe8, 0xd8, 0x10, 0x94, 0xcb, 0x03, + 0xbf, 0x56, 0x9c, 0xd2, 0x59, 0x05, 0x95, 0x8b, 0x57, 0x13, 0x59, 0xdb, 0x70, 0x0e, 0x92, 0xa6, + 0x07, 0xdb, 0x83, 0xef, 0x7a, 0x8d, 0x29, 0x7e, 0x4f, 0x66, 0xe0, 0x9e, 0x38, 0x8c, 0x09, 0xf6, + 0xa7, 0x0e, 0x17, 0xf3, 0xba, 0xab, 0x2a, 0x3f, 0x11, 0x73, 0x78, 0xb8, 0x3d, 0xbe, 0x73, 0xca, + 0x46, 0xc6, 0x67, 0xfa, 0x19, 0x3b, 0xa8, 0x4f, 0x1f, 0xea, 0x94, 0xd9, 0x0e, 0xb9, 0x83, 0x22, + 0x9d, 0xef, 0x2b, 0xa3, 0xaa, 0x39, 0x64, 0x44, 0x6f, 0x9f, 0x84, 0x27, 0xfe, 0x34, 0x15, 0x5f, + 0x56, 0xd0, 0x63, 0x1a, 0xa2, 0xe0, 0x8c, 0xd4, 0x58, 0x14, 0xd6, 0x87, 0xcb, 0x42, 0x54, 0x8b, + 0x4b, 0x7d, 0x38, 0xe6, 0x16, 0xe5, 0x42, 0x14, 0xee, 0xb3, 0xaa, 0xe1, 0x10, 0xcd, 0x5d, 0xb2, + 0x70, 0x46, 0xc7, 0xe7, 0x71, 0xb5, 0x27, 0xb0, 0xa9, 0x1a, 0x9e, 0x8b, 0x38, 0x42, 0x32, 0x1b, + 0xfa, 0xa9, 0xe9, 0xcd, 0xf8, 0xa2, 0x3d, 0xec, 0xb6, 0x40, 0x3e, 0x19, 0xba, 0xed, 0x1e, 0x61, + 0x3a, 0x3f, 0x89, 0xef, 0xe0, 0x3c, 0x34, 0x98, 0x68, 0x15, 0x99, 0x6a, 0xca, 0xf8, 0xc3, 0x1b, + 0xb8, 0x1d, 0xb0, 0xa2, 0xdb, 0x6d, 0x7f, 0xf4, 0xc8, 0x45, 0xca, 0xdd, 0xeb, 0x39, 0xc0, 0x45, + 0x6a, 0xd5, 0xcd, 0xae, 0xc7, 0x36, 0xb2, 0x30, 0x36, 0x82, 0xe5, 0x1d, 0x41, 0x0b, 0x9b, 0x95, + 0x39, 0x8c, 0x31, 0xbf, 0x15, 0x50, 0x80, 0x89, 0xa3, 0x19, 0x71, 0x35, 0xc3, 0x56, 0xa0, 0xc7, + 0xc1, 0x6b, 0x8c, 0x29, 0x9d, 0x93, 0xb5, 0x48, 0xd1, 0x60, 0x91, 0xd6, 0x45, 0x56, 0x59, 0x6e, + 0xf6, 0xdc, 0x01, 0xe5, 0xd0, 0x45, 0xd5, 0x83, 0xaf, 0x64, 0x9c, 0x5d, 0xbc, 0xab, 0x7d, 0x20, + 0x3d, 0xd2, 0xe8, 0xaf, 0x6c, 0xb9, 0x1b, 0xbd, 0x43, 0xeb, 0x5f, 0x91, 0x99, 0xf0, 0xcb, 0xd4, + 0x8d, 0x5d, 0xab, 0x75, 0x52, 0x36, 0xc9, 0xd5, 0xa8, 0xc4, 0x71, 0x91, 0x97, 0xfe, 0xcb, 0xb1, + 0x98, 0x92, 0x53, 0xac, 0x25, 0xc9, 0x89, 0xdd, 0xac, 0xa6, 0xe9, 0xb2, 0xd9, 0x75, 0x00, 0x36, + 0xd1, 0x26, 0x40, 0x07, 0xcb, 0x7a, 0x24, 0xa4, 0x51, 0xa6, 0x95, 0x50, 0x7b, 0x33, 0xa8, 0xe7, + 0x7d, 0xf3, 0x5f, 0x8c, 0xdb, 0xc0, 0xf7, 0xab, 0x94, 0xc5, 0xeb, 0xa9, 0xfb, 0xd6, 0x2f, 0xa7, + 0x4d, 0xaf, 0xce, 0xf0, 0xa8, 0x67, 0x78, 0xdb, 0x37, 0xa9, 0x8b, 0x0c, 0x34, 0x53, 0xc6, 0xec, + 0x6a, 0x73, 0xd2, 0x27, 0x81, 0x5f, 0xee, 0x4a, 0x3f, 0x66, 0x15, 0x8b, 0x29, 0xad, 0x6c, 0xe3, + 0x46, 0x0d, 0xfc, 0x49, 0xd6, 0x2c, 0x6e, 0x91, 0x89, 0x2d, 0x87, 0x55, 0xcf, 0x0d, 0x21, 0x82, + 0x8f, 0x10, 0x13, 0xc2, 0x9f, 0x01, 0x26, 0xe4, 0x9c, 0x58, 0x64, 0x21, 0x8e, 0x5e, 0x7d, 0xb2, + 0xf7, 0x61, 0xb5, 0xef, 0x8f, 0x31, 0x63, 0x33, 0x25, 0x06, 0xa7, 0x91, 0x39, 0xbc, 0x0c, 0xff, + 0xfd, 0xc8, 0xe9, 0x75, 0x73, 0x19, 0x65, 0xc5, 0x20, 0x4b, 0xaa, 0xc3, 0xa9, 0x63, 0xb9, 0x3e, + 0xee, 0x1c, 0x92, 0xc8, 0x94, 0xfc, 0xa1, 0x91, 0x61, 0x2a, 0x3c, 0x80, 0x19, 0xb9, 0x80, 0x93, + 0x3e, 0xc9, 0xe5, 0xa5, 0x94, 0xff, 0xaa, 0x2c, 0x0d, 0x2f, 0x3e, 0x1d, 0x5b, 0xbc, 0x0e, 0xd9, + 0x20, 0x5b, 0xe8, 0x77, 0xf6, 0x91, 0x9e, 0x33, 0xd2, 0x66, 0x7f, 0x5e, 0x8b, 0x14, 0x36, 0xbf, + 0xcc, 0x56, 0xaa, 0x38, 0xc3, 0xcb, 0x3e, 0x71, 0xa6, 0xc5, 0x52, 0x27, 0xe1, 0x85, 0xfa, 0x9c, + 0x62, 0x06, 0xd9, 0xf8, 0x43, 0x51, 0x82, 0x0a, 0x1f, 0x88, 0x59, 0xd9, 0x98, 0xa4, 0xcb, 0x30, + 0x76, 0x29, 0x70, 0xca, 0x34, 0xdf, 0x0e, 0xcb, 0x36, 0x04, 0x7d, 0x1f, 0x06, 0xe8, 0x6a, 0xdb, + 0x7d, 0x2e, 0x25, 0x37, 0xb4, 0x61, 0xcb, 0x80, 0x2b, 0x98, 0xfe, 0x1f, 0x4d, 0x0e, 0x12, 0x59, + 0xb2, 0xc2, 0x5d, 0xa9, 0xb9, 0xb5, 0xe5, 0xb9, 0xac, 0x4d, 0x99, 0x9c, 0xf2, 0x17, 0x27, 0x82, + 0x8e, 0x2a, 0xea, 0x47, 0xf4, 0xd1, 0xba, 0xae, 0x08, 0xb6, 0x57, 0xa7, 0x58, 0x66, 0xca, 0xf6, + 0x85, 0xe1, 0x5b, 0x13, 0x1f, 0x7c, 0xaa, 0x4e, 0xea, 0x7d, 0x91, 0x63, 0xdf, 0x04, 0xfd, 0x95, + 0xf8, 0x5b, 0xfb, 0x84, 0x31, 0x01, 0x73, 0x5f, 0x8e, 0x57, 0x93, 0xb1, 0xed, 0x1d, 0x4c, 0x4c, + 0xae, 0xc7, 0x4a, 0x9d, 0x61, 0xac, 0x8a, 0x11, 0x0d, 0x28, 0x34, 0xd6, 0x34, 0x07, 0x4c, 0x73, + 0x17, 0x18, 0x9a, 0x7f, 0xd9, 0x88, 0xfc, 0x13, 0x1d, 0x27, 0x88, 0x69, 0x72, 0xfa, 0x40, 0xb0, + 0xe7, 0x21, 0xc6, 0x01, 0xb7, 0xe9, 0x1d, 0x71, 0xce, 0xb0, 0x40, 0xeb, 0x5c, 0x60, 0x8b, 0x6b, + 0x57, 0x8a, 0xc9, 0x9f, 0xb4, 0xfe, 0xca, 0x7c, 0x59, 0xe2, 0x8c, 0x12, 0xb2, 0x49, 0x26, 0x4d, + 0x26, 0x31, 0x33, 0x1e, 0x3f, 0x60, 0x4c, 0xcc, 0xa7, 0x97, 0x89, 0xda, 0x69, 0xb2, 0xea, 0xb2, + 0x1b, 0xe9, 0xdb, 0x66, 0x14, 0xd2, 0x72, 0xfb, 0x9d, 0xde, 0xb8, 0x8b, 0x2a, 0x10, 0x84, 0xfa, + 0x4e, 0x60, 0xa0, 0x9f, 0xd3, 0x06, 0x7a, 0xd9, 0xc2, 0x88, 0xcb, 0xc6, 0xcc, 0xf2, 0xbc, 0xf5, + 0xf7, 0xe9, 0x80, 0xc0, 0x26, 0x2e, 0x48, 0xef, 0xf2, 0x47, 0x51, 0x57, 0xdb, 0xb7, 0x8a, 0x67, + 0xea, 0xc8, 0x4f, 0x00, 0x22, 0x93, 0x67, 0xdf, 0xb7, 0xff, 0x3d, 0x25, 0x66, 0xb8, 0x36, 0xae, + 0xfc, 0x48, 0x52, 0xf4, 0x27, 0x65, 0x67, 0x96, 0xf9, 0x53, 0x59, 0xf3, 0x1f, 0x4f, 0xfd, 0x1f, + 0x4d, 0x87, 0x3c, 0x4b, 0x4a, 0x8e, 0x58, 0xea, 0xe4, 0xb9, 0x84, 0x6c, 0xeb, 0xf3, 0xf1, 0xcc, + 0xc9, 0x0b, 0xca, 0xbe, 0x20, 0xbd, 0x36, 0x49, 0x9e, 0x08, 0xe7, 0xa6, 0x5f, 0x54, 0x13, 0x93, + 0x2e, 0xc3, 0x4b, 0x51, 0xe5, 0x65, 0x13, 0x57, 0xb5, 0xd1, 0x76, 0x7b, 0x27, 0x28, 0x45, 0x69, + 0x16, 0x42, 0x05, 0xb1, 0xde, 0x2a, 0x93, 0xd6, 0xcc, 0xed, 0x84, 0x05, 0x85, 0xff, 0x33, 0xad, + 0x24, 0x85, 0x48, 0xb5, 0x3e, 0x9d, 0x30, 0x75, 0x54, 0xb2, 0x5c, 0x62, 0xeb, 0xb8, 0xea, 0xe0, + 0x3b, 0x62, 0xb9, 0x6f, 0xb6, 0x94, 0xd8, 0xe2, 0xce, 0xd4, 0x51, 0xcc, 0xd2, 0xc2, 0xef, 0xa4, + 0xc4, 0x92, 0x59, 0x60, 0x78, 0x0b, 0x65, 0x89, 0x83, 0x54, 0x3a, 0xac, 0x48, 0xc8, 0x8e, 0x4c, + 0x90, 0x24, 0x5f, 0xc5, 0xd3, 0x68, 0x4b, 0x78, 0x0f, 0x15, 0xee, 0x1b, 0xe7, 0xa9, 0x0b, 0x3b, + 0x92, 0x27, 0x35, 0xde, 0x94, 0xcd, 0x29, 0x29, 0x61, 0xdc, 0x07, 0x79, 0x52, 0x12, 0x87, 0xaf, + 0xaa, 0x29, 0xb8, 0xa5, 0xb8, 0xef, 0xd0, 0xc2, 0x77, 0xda, 0xc3, 0x67, 0x0d, 0x18, 0x53, 0x9d, + 0xc9, 0x43, 0x96, 0x6c, 0x02, 0xcf, 0x4c, 0x6c, 0x60, 0xf6, 0xe0, 0x90, 0x49, 0xed, 0x2e, 0x32, + 0x1d, 0xe6, 0xf6, 0x1a, 0x6e, 0xee, 0xff, 0x4e, 0x4a, 0x09, 0xf1, 0x4c, 0x77, 0x38, 0x2b, 0x10, + 0xa9, 0xe7, 0xce, 0x85, 0x7d, 0x16, 0x30, 0x13, 0x7a, 0xf6, 0x99, 0x73, 0x12, 0x3d, 0x9b, 0x68, + 0xbf, 0xe2, 0x2e, 0xab, 0x42, 0xb9, 0xfc, 0x31, 0x74, 0x28, 0x7c, 0x28, 0xce, 0xc7, 0x0a, 0x43, + 0x18, 0xd2, 0xd4, 0x31, 0x60, 0x33, 0x0c, 0xcc, 0x98, 0x96, 0xbe, 0x55, 0x57, 0xf8, 0x33, 0x7c, + 0xc1, 0x59, 0xfa, 0x98, 0xa2, 0xe8, 0x1a, 0xa9, 0xe5, 0x04, 0xed, 0xf9, 0xcd, 0x55, 0x24, 0x72, + 0x47, 0x32, 0x27, 0x0a, 0xa5, 0x2a, 0x00, 0x67, 0x10, 0xfd, 0xc1, 0x34, 0x27, 0xea, 0xac, 0xb2, + 0x32, 0xcf, 0x85, 0x7c, 0xe1, 0xf5, 0xfb, 0x29, 0x25, 0xab, 0x46, 0x3f, 0x7b, 0x8a, 0x7a, 0x6d, + 0x72, 0x87, 0xf8, 0x03, 0xbf, 0x8d, 0xaf, 0xf6, 0xac, 0x5b, 0x17, 0x57, 0x6b, 0x9b, 0x75, 0x5b, + 0x66, 0x7e, 0x4b, 0x5b, 0xff, 0x4c, 0x46, 0xca, 0xc1, 0x14, 0x9a, 0xe8, 0xe7, 0xe7, 0x74, 0x9b, + 0xf5, 0x32, 0x7a, 0x3b, 0xd2, 0xe2, 0x4d, 0x87, 0x47, 0x3e, 0x94, 0xb7, 0xc4, 0x2c, 0x39, 0x43, + 0x86, 0x09, 0x78, 0xac, 0x77, 0x91, 0xc7, 0x98, 0xe2, 0x3f, 0x99, 0x91, 0x71, 0x33, 0x17, 0x50, + 0x61, 0xcc, 0xad, 0xd5, 0xb5, 0xd4, 0x32, 0x0a, 0x3b, 0x9b, 0xf1, 0xa7, 0xd8, 0x2f, 0x1b, 0x38, + 0x58, 0x24, 0x29, 0x0a, 0xe3, 0x16, 0xfe, 0x0c, 0x50, 0x76, 0x52, 0x67, 0xbe, 0xed, 0x4c, 0xd3, + 0xde, 0x17, 0xf3, 0xf2, 0xa3, 0x4a, 0x7d, 0x78, 0x6b, 0xda, 0xa4, 0x8b, 0x4f, 0xb8, 0x71, 0xfe, + 0x3d, 0xb1, 0x88, 0x23, 0xda, 0x72, 0xbd, 0x59, 0xc3, 0x58, 0x1b, 0xef, 0xaa, 0x57, 0x51, 0x78, + 0x53, 0xcc, 0xa9, 0x11, 0x10, 0x30, 0x78, 0xc6, 0xc1, 0x9a, 0xcc, 0x37, 0x5a, 0x59, 0xeb, 0x55, + 0x16, 0xc8, 0x25, 0x0c, 0x7f, 0xee, 0x00, 0xa8, 0xf7, 0xbb, 0x2d, 0xf4, 0x36, 0x76, 0x4e, 0x94, + 0x55, 0x12, 0xb3, 0xc8, 0x10, 0x2e, 0x4e, 0xae, 0x46, 0xd5, 0x59, 0xd7, 0x7d, 0xee, 0xfa, 0x06, + 0x2b, 0xc4, 0x0b, 0x4c, 0x6e, 0x5f, 0xdc, 0x90, 0x8d, 0x0b, 0x4f, 0x30, 0x68, 0x29, 0xff, 0x8d, + 0x24, 0x48, 0x0d, 0x12, 0xe4, 0x2b, 0x21, 0x47, 0x3b, 0xf2, 0xf9, 0x05, 0xb2, 0xd6, 0xf5, 0x5e, + 0xd8, 0xf8, 0x86, 0x39, 0x08, 0x99, 0x63, 0xd6, 0x74, 0x7a, 0x9e, 0xaf, 0xc2, 0xa3, 0xfc, 0x5e, + 0xca, 0xd4, 0x72, 0xef, 0x0e, 0xbd, 0xe7, 0x6e, 0xd7, 0x69, 0x8e, 0x41, 0xf8, 0x38, 0x91, 0x00, + 0xbb, 0x2e, 0x16, 0x54, 0x8c, 0x51, 0x35, 0x65, 0xbe, 0x00, 0x13, 0xbb, 0x14, 0x4d, 0xf6, 0xca, + 0xa7, 0x0a, 0x5b, 0xa1, 0x85, 0x6c, 0xe1, 0x3d, 0x31, 0xaf, 0xeb, 0x01, 0x0f, 0xd0, 0x66, 0x86, + 0x18, 0x6e, 0xca, 0x07, 0x4f, 0x9d, 0x38, 0x43, 0xbe, 0xca, 0xfa, 0xa0, 0xad, 0x39, 0x95, 0x63, + 0x40, 0x88, 0x1d, 0xaf, 0xcf, 0x16, 0xa5, 0x49, 0x21, 0x91, 0x0a, 0x22, 0xcf, 0x0e, 0xc2, 0x20, + 0x39, 0x38, 0xb2, 0x87, 0x72, 0x38, 0x95, 0x47, 0x19, 0xa0, 0x5f, 0x35, 0xa4, 0xc1, 0x64, 0x5a, + 0x9f, 0x29, 0xaa, 0xda, 0xf2, 0xb8, 0xa1, 0xd9, 0x28, 0xff, 0x40, 0x9c, 0x53, 0xa3, 0xda, 0x1c, + 0xd1, 0x59, 0xda, 0x9e, 0x03, 0x27, 0xde, 0xd8, 0x3c, 0xad, 0x72, 0xd4, 0x21, 0xbf, 0x85, 0x7a, + 0x8b, 0x0d, 0x80, 0x4f, 0xef, 0x50, 0x6e, 0x37, 0xa5, 0x38, 0xc3, 0xdf, 0x21, 0x97, 0x0a, 0x73, + 0x27, 0x1e, 0xb1, 0xc4, 0x1b, 0xcc, 0xab, 0xa5, 0x3d, 0xde, 0x49, 0x2d, 0x36, 0xf4, 0x06, 0xa1, + 0xc7, 0x02, 0x1a, 0x43, 0xcb, 0xb7, 0x09, 0x9a, 0x9a, 0x02, 0xcf, 0x1e, 0xd9, 0x06, 0x8c, 0x72, + 0xa3, 0x93, 0xda, 0x57, 0xbe, 0x18, 0xbb, 0x03, 0x34, 0xfc, 0xcd, 0x3a, 0xf4, 0x97, 0x3c, 0xfc, + 0x4b, 0xc5, 0x72, 0xa4, 0x4d, 0xb3, 0xe7, 0x8d, 0xac, 0x37, 0x59, 0xc5, 0x31, 0x75, 0x2c, 0x6d, + 0xcf, 0x8a, 0xed, 0xff, 0x56, 0xbc, 0x31, 0x08, 0xc8, 0x77, 0x4e, 0x6d, 0xa4, 0x21, 0xe9, 0x8c, + 0xb3, 0x0c, 0xd9, 0x74, 0xd4, 0x98, 0xbd, 0x1e, 0xb2, 0x53, 0x75, 0x74, 0x91, 0x04, 0x89, 0xee, + 0xb5, 0xa9, 0x0d, 0xcc, 0x97, 0xa2, 0x92, 0xa1, 0x54, 0xf4, 0xeb, 0x7d, 0x3e, 0x97, 0xa4, 0xae, + 0x70, 0x49, 0x0e, 0xd1, 0xdf, 0x3e, 0xf1, 0xf5, 0xc4, 0x6f, 0x67, 0x59, 0xb5, 0x34, 0xad, 0xe3, + 0x54, 0x81, 0x05, 0x09, 0xe2, 0x78, 0x38, 0xb4, 0xc3, 0xae, 0x59, 0x94, 0xb3, 0x6d, 0x60, 0x8a, + 0xad, 0x19, 0x1d, 0xeb, 0x59, 0xb7, 0x36, 0x5c, 0xc0, 0xd0, 0x69, 0x8c, 0x2a, 0xa0, 0x17, 0x3f, + 0x1e, 0x20, 0x26, 0xda, 0x31, 0x92, 0x9d, 0xeb, 0x6a, 0xee, 0x36, 0xab, 0xca, 0x49, 0xab, 0x1d, + 0x94, 0xcf, 0x29, 0xad, 0x9c, 0x2e, 0x27, 0x46, 0x7c, 0x5e, 0x69, 0x0a, 0xb0, 0x84, 0x9f, 0x96, + 0x19, 0x93, 0x5b, 0x48, 0xa8, 0x0d, 0x5e, 0x8d, 0x0b, 0xb5, 0xd0, 0x3e, 0x08, 0xa7, 0x7a, 0xa1, + 0x5a, 0xfd, 0x8e, 0x1c, 0xb9, 0x2e, 0x5d, 0x0a, 0x1e, 0x23, 0xa8, 0x52, 0x9e, 0xd7, 0xb2, 0xa1, + 0x6a, 0x78, 0x6e, 0xa3, 0x5e, 0x9f, 0x43, 0xc9, 0xad, 0x90, 0x66, 0x5f, 0xad, 0x2f, 0x28, 0x3f, + 0xa7, 0xca, 0xe9, 0xa3, 0x41, 0x79, 0x8e, 0xca, 0x01, 0xbf, 0x60, 0xe2, 0x3e, 0x5a, 0x5f, 0x50, + 0x77, 0x5e, 0xd5, 0xe9, 0xbd, 0x0a, 0xea, 0xf2, 0x2a, 0xdc, 0xa1, 0xb2, 0x3c, 0x13, 0x53, 0x73, + 0x41, 0xe9, 0xcc, 0x58, 0x66, 0x51, 0xab, 0xa0, 0xc4, 0x7d, 0xd6, 0x7d, 0x66, 0xdd, 0x43, 0xa0, + 0xd1, 0x82, 0x0b, 0x7e, 0x74, 0xa2, 0x42, 0x79, 0xc6, 0xc0, 0xe9, 0x6f, 0x52, 0x2c, 0xfc, 0x4f, + 0xe8, 0x33, 0x15, 0x92, 0x3e, 0x12, 0xf3, 0x23, 0x6c, 0x19, 0x84, 0xbd, 0x78, 0xb3, 0x78, 0x86, + 0xb1, 0x8a, 0x5c, 0x14, 0x5b, 0x1a, 0xa9, 0x03, 0x0b, 0x5b, 0x62, 0x56, 0xd6, 0x23, 0xf7, 0x4e, + 0x7f, 0x85, 0x60, 0x57, 0x16, 0x19, 0xca, 0x56, 0x2c, 0x25, 0x27, 0xf3, 0x31, 0xa9, 0x51, 0x94, + 0x56, 0xe3, 0xb9, 0x92, 0x63, 0x34, 0xe2, 0xa3, 0x9e, 0x25, 0xd4, 0x13, 0x3b, 0xdd, 0xb3, 0x8f, + 0x8e, 0x84, 0x92, 0x4b, 0xd1, 0x75, 0x91, 0x6b, 0x32, 0x89, 0xdf, 0x65, 0x4d, 0xdd, 0x1a, 0x6b, + 0x79, 0x92, 0x9e, 0x51, 0x95, 0xe1, 0xd3, 0x89, 0xa7, 0xf0, 0xdf, 0xa7, 0x12, 0x70, 0xab, 0xd1, + 0x09, 0xb1, 0x11, 0x3e, 0x18, 0x9b, 0xc1, 0xe7, 0x6b, 0x0a, 0x69, 0x45, 0x37, 0x3b, 0xa1, 0x4b, + 0x51, 0xfd, 0x55, 0x78, 0x21, 0xe6, 0xd5, 0xdf, 0xc4, 0xbc, 0xd0, 0x33, 0x38, 0xb5, 0xf0, 0x4d, + 0x10, 0x3d, 0xb1, 0x20, 0x64, 0xfe, 0xaf, 0x44, 0x06, 0x23, 0xf3, 0x3f, 0x3a, 0xec, 0x24, 0x94, + 0xdb, 0x95, 0xe3, 0xc1, 0xe8, 0x44, 0xbf, 0xaf, 0x63, 0xfa, 0x93, 0x31, 0xf9, 0xa0, 0x49, 0xdb, + 0x41, 0x2e, 0x33, 0xd6, 0x7f, 0x27, 0xd9, 0xea, 0xa0, 0x15, 0x07, 0xb7, 0x93, 0xd6, 0xc1, 0xd1, + 0x98, 0x88, 0xbf, 0x7c, 0xf6, 0x8d, 0xa4, 0x4a, 0x8a, 0x7b, 0x31, 0x39, 0x9d, 0x1e, 0xf3, 0x03, + 0x41, 0x46, 0x99, 0xcd, 0x70, 0xbe, 0x07, 0x9a, 0xd8, 0x39, 0xe9, 0xf4, 0x58, 0x54, 0x27, 0x8f, + 0xd6, 0x17, 0x4e, 0x7b, 0x88, 0x0e, 0x2e, 0xac, 0x1f, 0x5c, 0x66, 0x17, 0xe4, 0x40, 0x35, 0xad, + 0x85, 0x3b, 0x7f, 0x74, 0xd2, 0x23, 0x1d, 0x46, 0x86, 0x47, 0x07, 0x91, 0xd0, 0x1b, 0x1e, 0x62, + 0x3c, 0x59, 0x9c, 0xc5, 0x02, 0xcd, 0x02, 0x90, 0x87, 0xf1, 0x8c, 0xac, 0x0b, 0xc0, 0xc2, 0xe2, + 0x3a, 0xb2, 0x4b, 0x37, 0x93, 0x96, 0x85, 0x3a, 0x78, 0xf5, 0x22, 0xe4, 0x9f, 0xc2, 0xc2, 0xac, + 0x8f, 0x95, 0x75, 0x4f, 0xdd, 0x95, 0x60, 0xe3, 0x75, 0x94, 0x41, 0x64, 0x37, 0x28, 0x37, 0x12, + 0xfe, 0x85, 0x9a, 0xeb, 0x60, 0xba, 0xd6, 0x77, 0x94, 0xe9, 0x4d, 0xdf, 0x35, 0x63, 0x85, 0x67, + 0x1a, 0xe1, 0xdf, 0x8a, 0xe1, 0xa1, 0x86, 0x03, 0x57, 0xad, 0x6b, 0x28, 0xfc, 0x10, 0x52, 0x26, + 0xbc, 0x31, 0x79, 0xee, 0x3a, 0x2f, 0x6c, 0xa5, 0x19, 0xb1, 0x0d, 0xdb, 0x3e, 0x32, 0x9b, 0x9e, + 0x6f, 0x63, 0xbd, 0x26, 0x69, 0x28, 0x7d, 0xa2, 0xb1, 0x61, 0x04, 0x47, 0x66, 0x68, 0x94, 0x7b, + 0x6e, 0xff, 0x99, 0x6f, 0x1f, 0x78, 0xe4, 0xaf, 0xab, 0x32, 0x18, 0x3e, 0x8c, 0x72, 0x4f, 0xa4, + 0x3a, 0x66, 0xff, 0x02, 0x76, 0x31, 0xea, 0xc6, 0xdf, 0x6f, 0xa5, 0x42, 0xef, 0xb7, 0xe2, 0x94, + 0x9e, 0x25, 0x41, 0xd3, 0xa1, 0x2c, 0x11, 0x29, 0xfc, 0x75, 0x46, 0xd9, 0xf4, 0xd4, 0xc7, 0x43, + 0x1d, 0xa7, 0x93, 0x78, 0xf9, 0x1e, 0x0e, 0x7d, 0x1d, 0x18, 0x39, 0xa7, 0x39, 0x84, 0x3f, 0xaa, + 0xbe, 0xcc, 0x18, 0x1d, 0xa8, 0x0f, 0x73, 0xda, 0x7d, 0xb2, 0x3b, 0x67, 0x15, 0x0c, 0x51, 0xc9, + 0x97, 0x03, 0x28, 0x9a, 0xd1, 0x61, 0x74, 0xb1, 0x08, 0xb1, 0xdd, 0x11, 0x3a, 0x7d, 0xb0, 0xa1, + 0x1c, 0xad, 0x90, 0xed, 0x63, 0xf6, 0x0c, 0x9e, 0x0b, 0x30, 0xa8, 0x8b, 0xae, 0x67, 0x6c, 0xf1, + 0xd6, 0xcf, 0x53, 0x0e, 0xdc, 0x21, 0x20, 0xca, 0xfd, 0x9e, 0xe7, 0x75, 0x41, 0xa0, 0x68, 0x03, + 0x81, 0x57, 0x34, 0x1c, 0xa4, 0x0d, 0xb3, 0xf2, 0x10, 0xf6, 0xb1, 0x2f, 0x09, 0x38, 0xf2, 0x1e, + 0x70, 0x33, 0x5c, 0x74, 0x7b, 0xc3, 0xf1, 0x9c, 0x6e, 0xf0, 0x68, 0xb1, 0xed, 0x1c, 0xba, 0x20, + 0x62, 0xd8, 0x7e, 0x9f, 0x54, 0x85, 0x8a, 0x8e, 0xc3, 0x4c, 0xe1, 0x97, 0x83, 0x35, 0x08, 0x74, + 0xfd, 0x80, 0x8a, 0xe3, 0xbb, 0x18, 0xf4, 0x63, 0x1b, 0xb5, 0x91, 0xc7, 0x0f, 0x2c, 0xea, 0x07, + 0x98, 0x58, 0x45, 0xa2, 0xf5, 0x73, 0xca, 0x68, 0x8f, 0x9e, 0xf7, 0xb2, 0x2c, 0xa7, 0x76, 0xc0, + 0x1f, 0x0f, 0x28, 0x32, 0x0b, 0x17, 0x9f, 0x57, 0x4d, 0x07, 0x63, 0x5f, 0x99, 0xfe, 0x98, 0x62, + 0xc3, 0x82, 0x50, 0x12, 0x04, 0x50, 0xec, 0xb9, 0x23, 0x45, 0x4a, 0x2e, 0x90, 0xad, 0x7e, 0x83, + 0xed, 0xbe, 0x06, 0x3a, 0x20, 0x3d, 0x29, 0xc5, 0x64, 0xa0, 0xf3, 0x2a, 0x9b, 0xe1, 0x14, 0x89, + 0xc5, 0x08, 0xe5, 0xb7, 0xe0, 0xab, 0x32, 0xe2, 0x60, 0x64, 0x01, 0x58, 0x4c, 0x18, 0x45, 0x02, + 0xc8, 0x84, 0x61, 0x0c, 0x20, 0x09, 0x62, 0xb9, 0x10, 0x2e, 0xf3, 0x07, 0x20, 0x9a, 0xb7, 0x47, + 0x9e, 0x19, 0x0f, 0x3a, 0x6b, 0xbd, 0x2d, 0xee, 0x4d, 0x9a, 0xbb, 0xcf, 0x4e, 0x2e, 0x3e, 0x3f, + 0x24, 0x57, 0x02, 0xd1, 0x5f, 0xa6, 0x44, 0x71, 0xd2, 0x3c, 0xa3, 0x3d, 0xa6, 0xc0, 0x72, 0x55, + 0xcc, 0x98, 0xc1, 0x54, 0xd6, 0xbf, 0xe2, 0x98, 0xc5, 0xa0, 0x41, 0xe1, 0x43, 0x21, 0x82, 0x5f, + 0x13, 0xf7, 0x25, 0xa2, 0x6d, 0xe2, 0xa4, 0xd8, 0xf5, 0xe8, 0xc9, 0x35, 0x31, 0xe6, 0x5c, 0x6f, + 0xd3, 0x71, 0xba, 0x68, 0x14, 0x2e, 0xb3, 0x17, 0xb8, 0x11, 0x1f, 0x23, 0x64, 0x3e, 0xcb, 0x9a, + 0x9e, 0xe2, 0xec, 0x02, 0xf0, 0x71, 0xf4, 0x10, 0x27, 0x0c, 0x18, 0xb8, 0x10, 0xfa, 0xe3, 0x40, + 0x6e, 0x9c, 0xb7, 0x8e, 0xa6, 0x4f, 0x48, 0xc6, 0xc0, 0x32, 0x4c, 0xcc, 0xb1, 0x50, 0x58, 0x11, + 0xfb, 0x00, 0x1c, 0x7c, 0xf0, 0x48, 0xcf, 0xd0, 0x98, 0x9e, 0x36, 0x53, 0xfd, 0xa5, 0x49, 0x33, + 0xdd, 0x14, 0x6f, 0x85, 0x67, 0x1a, 0x3a, 0xa7, 0xe0, 0x40, 0x4e, 0x03, 0xfb, 0x9f, 0x61, 0x00, + 0x0c, 0xe6, 0x31, 0x71, 0x9c, 0x53, 0x00, 0x3f, 0xf1, 0x80, 0x5f, 0x8b, 0x92, 0x1f, 0xf5, 0xbe, + 0xe5, 0x11, 0x09, 0x17, 0x0a, 0xa8, 0x7f, 0x2d, 0x1b, 0xa5, 0x94, 0xd1, 0x76, 0x3a, 0xa1, 0x96, + 0xe8, 0x00, 0x02, 0x3a, 0xf4, 0x88, 0x97, 0x4f, 0x19, 0xc1, 0x91, 0x4f, 0xeb, 0x0a, 0x3c, 0x1b, + 0xf5, 0x3b, 0x29, 0xfc, 0x61, 0x4a, 0x2c, 0xa0, 0xf6, 0x60, 0xd3, 0x75, 0x7a, 0x5d, 0xb8, 0x08, + 0x0b, 0x14, 0xff, 0xd9, 0x88, 0x7a, 0x74, 0xb9, 0x58, 0x31, 0xc7, 0xc0, 0xb6, 0xc4, 0xa5, 0x5d, + 0x07, 0x2e, 0x2d, 0xa9, 0xc2, 0xc6, 0x1f, 0x55, 0xca, 0x35, 0x37, 0x76, 0xfb, 0xa3, 0x07, 0x6b, + 0xa6, 0xce, 0x44, 0x95, 0xbe, 0xff, 0xae, 0xc9, 0xbf, 0x91, 0x7e, 0x05, 0x70, 0x3a, 0x50, 0x6b, + 0x2e, 0xd5, 0xee, 0x1b, 0x07, 0x3d, 0xaf, 0xad, 0x58, 0x3d, 0x22, 0x13, 0x85, 0x56, 0x10, 0x94, + 0x81, 0xfc, 0xb6, 0x36, 0xc4, 0x22, 0xcd, 0xf8, 0x00, 0xe7, 0xaf, 0x36, 0xe1, 0xed, 0xb3, 0x6d, + 0x82, 0x5e, 0x77, 0xe1, 0x77, 0x53, 0xc8, 0xba, 0xf2, 0x96, 0x10, 0x49, 0x90, 0x7f, 0xdb, 0x2f, + 0x1c, 0x44, 0xdd, 0xd2, 0x9b, 0xf4, 0x2d, 0xb1, 0x88, 0xcf, 0x96, 0xd5, 0xb7, 0x38, 0x60, 0xf2, + 0x95, 0xf0, 0xfe, 0xb4, 0xa0, 0x01, 0xef, 0xe5, 0x63, 0xe3, 0x95, 0x95, 0x0c, 0x5b, 0xc2, 0xfa, + 0xc3, 0xb5, 0xb3, 0xcd, 0xce, 0x2c, 0xb6, 0x76, 0xf9, 0x82, 0x44, 0xaf, 0x22, 0xd9, 0x9b, 0x92, + 0x91, 0x43, 0xc4, 0x02, 0x15, 0x43, 0x0e, 0x9f, 0xf0, 0x95, 0x89, 0x5e, 0xb9, 0xf8, 0x88, 0x93, + 0xee, 0xdc, 0x53, 0x71, 0x7b, 0xe2, 0x94, 0x4e, 0x8b, 0xe5, 0x83, 0x52, 0x35, 0xd0, 0x74, 0xf4, + 0x03, 0x41, 0x66, 0x2a, 0x12, 0xf3, 0x1c, 0xf3, 0x02, 0xbc, 0x31, 0x71, 0x72, 0xd1, 0xa8, 0x39, + 0xd1, 0x89, 0xe5, 0xcb, 0xf8, 0x9a, 0x9b, 0x26, 0xaf, 0x10, 0xfa, 0xfd, 0xe2, 0x59, 0x47, 0x2b, + 0xca, 0x65, 0x17, 0x3e, 0x17, 0x73, 0xf2, 0xcf, 0x89, 0xdc, 0x4f, 0x3c, 0x1f, 0x44, 0x82, 0x2d, + 0xc8, 0xd8, 0x77, 0xf6, 0x39, 0x59, 0x33, 0xf2, 0xb7, 0xa2, 0xcf, 0x3a, 0x87, 0x26, 0x07, 0xb9, + 0xaa, 0xec, 0xb5, 0x3b, 0x47, 0x08, 0xf4, 0x2f, 0xda, 0x30, 0x73, 0xa0, 0x8b, 0xf0, 0x53, 0x7b, + 0x80, 0x5f, 0x36, 0x3c, 0xc0, 0xc9, 0xa5, 0x9e, 0xc3, 0x2d, 0xa1, 0x58, 0x8f, 0x89, 0xfa, 0x38, + 0x68, 0x5a, 0x38, 0xb2, 0x17, 0xc0, 0x4c, 0x90, 0x5c, 0x81, 0x82, 0x70, 0x51, 0x47, 0xf6, 0x0f, + 0xf5, 0xcd, 0xa8, 0x8b, 0xb2, 0x1b, 0xdf, 0x9e, 0x59, 0xb3, 0x86, 0x1c, 0xf3, 0x75, 0x06, 0x16, + 0xeb, 0xae, 0xe9, 0x5e, 0xcc, 0xf3, 0xc0, 0xb8, 0x92, 0xd2, 0x15, 0x76, 0x49, 0x64, 0x49, 0xc3, + 0xcb, 0x73, 0x5e, 0x0b, 0x7c, 0x6b, 0xa8, 0xe1, 0x8e, 0x03, 0x22, 0x0d, 0x7f, 0x1c, 0xb1, 0xa6, + 0x87, 0x09, 0x67, 0xe4, 0x2b, 0x03, 0x3d, 0xe3, 0x47, 0x46, 0xac, 0x45, 0xdd, 0x47, 0x1f, 0x34, + 0x65, 0x07, 0xa5, 0x8c, 0x4a, 0x5e, 0xb4, 0x27, 0x47, 0xc9, 0x47, 0x0f, 0x57, 0xe9, 0x69, 0xf5, + 0x3d, 0x23, 0xdc, 0xa4, 0x31, 0xd2, 0xa0, 0x77, 0x12, 0x4b, 0x43, 0x08, 0x08, 0x2e, 0xf6, 0x41, + 0x34, 0x95, 0x14, 0x00, 0xc1, 0x25, 0x55, 0xe0, 0xab, 0x91, 0xbf, 0x35, 0x32, 0xfc, 0x71, 0xcc, + 0x4d, 0x17, 0x6e, 0x0d, 0x39, 0x3a, 0x75, 0x9c, 0x58, 0x84, 0xcd, 0x59, 0xc4, 0x1c, 0x5c, 0xc2, + 0x61, 0x31, 0xd2, 0x32, 0xf4, 0x86, 0x0c, 0x31, 0x40, 0x23, 0x14, 0xc9, 0xde, 0xb5, 0x9e, 0xde, + 0xab, 0xea, 0x8d, 0xcc, 0xa8, 0x5c, 0x6b, 0xf8, 0xc8, 0x61, 0x30, 0x74, 0x31, 0x10, 0xc0, 0x89, + 0x7c, 0x8b, 0xbe, 0x16, 0x24, 0x6e, 0x60, 0xd3, 0xc2, 0x2b, 0xc5, 0x89, 0x13, 0x52, 0x09, 0x4e, + 0xee, 0x4c, 0x49, 0x70, 0x82, 0x42, 0x1e, 0x41, 0x1c, 0xef, 0xdf, 0x3f, 0x98, 0x29, 0x0c, 0xd1, + 0x8a, 0x1c, 0x5d, 0xa0, 0x8e, 0xfe, 0xa6, 0x17, 0xc8, 0x25, 0x89, 0x0b, 0xa4, 0x11, 0x8c, 0x05, + 0xd2, 0x06, 0xf9, 0x3e, 0x46, 0xed, 0x90, 0x8b, 0x7c, 0xcf, 0xb4, 0x75, 0x67, 0x8d, 0xf7, 0xb5, + 0x36, 0x92, 0xdb, 0x1d, 0x74, 0x7a, 0xca, 0xf3, 0xcf, 0xd2, 0x4e, 0x65, 0xa7, 0xbe, 0x51, 0xe1, + 0xd0, 0x24, 0xd1, 0x90, 0x9d, 0x3a, 0xd3, 0x41, 0x90, 0x47, 0xcc, 0x4c, 0x2d, 0x9c, 0x40, 0xae, + 0x29, 0xee, 0x9a, 0x36, 0xe7, 0x51, 0x62, 0x7b, 0xeb, 0x5f, 0x4d, 0x31, 0x6e, 0xa4, 0x9b, 0xa3, + 0x69, 0x3e, 0xaa, 0x97, 0x00, 0xd6, 0xd5, 0x2b, 0x1f, 0xd4, 0x43, 0x6e, 0xf3, 0x83, 0xf8, 0x84, + 0xfd, 0x88, 0x7f, 0x88, 0x39, 0x20, 0x74, 0x44, 0xa3, 0x96, 0x66, 0x0a, 0xa3, 0xe8, 0x43, 0xc0, + 0xac, 0x4a, 0x79, 0x7e, 0x3b, 0x3e, 0x0b, 0x49, 0x32, 0xe0, 0x22, 0xf8, 0x47, 0xd3, 0x26, 0x80, + 0x31, 0x57, 0xe4, 0x73, 0x7d, 0x6d, 0xcd, 0x4f, 0x07, 0x36, 0x67, 0x02, 0x64, 0xb2, 0xd4, 0xf0, + 0x73, 0x2a, 0xd2, 0x3a, 0x50, 0x21, 0x13, 0x62, 0x49, 0x82, 0x51, 0x24, 0xc1, 0xfc, 0x89, 0x7d, + 0x3e, 0x57, 0xe5, 0x03, 0x65, 0x20, 0xb5, 0x59, 0x89, 0xd4, 0xe2, 0x4a, 0x6c, 0xf9, 0x38, 0xce, + 0x41, 0xe6, 0x24, 0xc9, 0x2b, 0xf4, 0x8f, 0x33, 0x09, 0x8a, 0x6d, 0xb3, 0x93, 0xe9, 0x0e, 0xe0, + 0x3b, 0x06, 0x8f, 0x73, 0xaf, 0x78, 0xa6, 0x7e, 0x45, 0xfe, 0x59, 0xf8, 0x8b, 0xb4, 0x98, 0x0d, + 0xa6, 0xc1, 0x23, 0x85, 0xf2, 0x39, 0x04, 0x2f, 0x8f, 0xd3, 0xd2, 0xc5, 0x4b, 0xbe, 0xb0, 0x34, + 0xe9, 0xf5, 0x59, 0x3f, 0x47, 0x49, 0xb5, 0x49, 0xe1, 0xc2, 0x1f, 0x32, 0x14, 0x29, 0x28, 0xc9, + 0x1d, 0x61, 0x98, 0x04, 0x23, 0x38, 0x43, 0xf8, 0xe4, 0x67, 0x95, 0x4c, 0xda, 0x3e, 0xc0, 0xe0, + 0xb4, 0xc1, 0x5c, 0xe7, 0x94, 0x90, 0xdb, 0xa7, 0xe8, 0x12, 0xca, 0xff, 0x2c, 0x70, 0x7e, 0x59, + 0x2e, 0x74, 0x44, 0x36, 0x31, 0x1d, 0xe9, 0xd9, 0x32, 0x27, 0xc3, 0x3c, 0xa8, 0x84, 0x45, 0xc9, + 0x6c, 0xa8, 0x23, 0xf9, 0xc1, 0xcf, 0xc8, 0x47, 0x59, 0x11, 0x1d, 0x5a, 0x69, 0x00, 0x38, 0x75, + 0xcb, 0x39, 0x06, 0x62, 0xb9, 0xef, 0xf6, 0x01, 0xb5, 0x40, 0x27, 0x19, 0xf6, 0xc3, 0xbe, 0x1f, + 0xbc, 0x2f, 0x52, 0x45, 0x6b, 0xd2, 0x72, 0xf9, 0x1b, 0x29, 0x71, 0xb1, 0xbc, 0x31, 0x3e, 0x3e, + 0x3e, 0xd9, 0xeb, 0xef, 0xa3, 0xab, 0xbc, 0x0a, 0xa8, 0x7b, 0x1f, 0xf8, 0x39, 0x2c, 0x66, 0x26, + 0x4b, 0x1a, 0xb0, 0x0c, 0xdf, 0x2c, 0x8c, 0xcb, 0x14, 0x58, 0x97, 0x48, 0xc8, 0xfa, 0x54, 0x5c, + 0x68, 0xf7, 0x99, 0x9e, 0x98, 0x5d, 0x19, 0x07, 0x9d, 0x2f, 0x56, 0x82, 0xe6, 0x8c, 0x81, 0x10, + 0xb1, 0x47, 0xca, 0xec, 0xbd, 0xfe, 0xb3, 0xbe, 0xf7, 0xa2, 0x8f, 0x1e, 0x0c, 0x89, 0xda, 0x34, + 0x8e, 0xd7, 0xd0, 0x70, 0x3a, 0xee, 0x80, 0x72, 0xac, 0x73, 0x78, 0x34, 0x33, 0xc7, 0xfa, 0xb4, + 0x1e, 0x45, 0x7a, 0x78, 0x45, 0xce, 0x9a, 0xf8, 0xd3, 0x88, 0xad, 0xc1, 0xae, 0x43, 0x6f, 0x88, + 0x6c, 0x72, 0x84, 0x31, 0x43, 0x8b, 0xca, 0x9c, 0xd1, 0xbf, 0x9b, 0x8e, 0x5a, 0x66, 0xe2, 0x5f, + 0xd3, 0xf7, 0xe6, 0xbb, 0x91, 0x5c, 0x8c, 0x2b, 0xf2, 0xe5, 0xcb, 0x59, 0x3a, 0x93, 0xc7, 0x00, + 0xfd, 0xb5, 0x7e, 0x5e, 0x17, 0xda, 0xd2, 0x21, 0x14, 0x73, 0x4a, 0x2d, 0xe8, 0x06, 0xe8, 0x1c, + 0x10, 0x6b, 0x92, 0xfb, 0x06, 0xe6, 0xe7, 0x0b, 0x8a, 0xeb, 0x07, 0x07, 0x0e, 0x22, 0x96, 0x0d, + 0xf9, 0xe6, 0x2f, 0x97, 0x02, 0x7a, 0x7e, 0x39, 0xa8, 0x07, 0xce, 0xa0, 0xdd, 0x73, 0x39, 0xae, + 0x4c, 0x2e, 0x8d, 0x09, 0x3c, 0xcc, 0xba, 0x11, 0xba, 0xb6, 0xf7, 0xd8, 0xf7, 0x34, 0x13, 0xae, + 0xdc, 0x71, 0x7d, 0x1f, 0xc6, 0xe5, 0x1b, 0x99, 0xa3, 0x70, 0xc9, 0x57, 0xca, 0x32, 0xf6, 0x2c, + 0x48, 0x6d, 0xea, 0x65, 0x9a, 0x0c, 0x9c, 0x21, 0x9f, 0xbf, 0x33, 0x58, 0x5d, 0x0a, 0x3f, 0x7f, + 0xdf, 0xc1, 0x60, 0x46, 0xed, 0x5e, 0xf4, 0xbd, 0x78, 0xa2, 0x43, 0x31, 0x10, 0x0c, 0xdf, 0xfd, + 0x81, 0xba, 0x28, 0xe8, 0x3d, 0x80, 0xaf, 0xfc, 0xf0, 0x61, 0x28, 0x85, 0x58, 0x71, 0xbe, 0xc4, + 0x67, 0x17, 0x36, 0x85, 0x74, 0xf2, 0x9f, 0xd1, 0xb5, 0x9e, 0x2f, 0x3c, 0x10, 0x0b, 0xe8, 0x5a, + 0xdd, 0x43, 0x89, 0x22, 0xcc, 0x2a, 0x4e, 0x89, 0xcd, 0xfe, 0x0b, 0x69, 0xbc, 0x28, 0x98, 0xb8, + 0x37, 0x88, 0x1c, 0xa6, 0x3c, 0xa2, 0x63, 0x5c, 0x29, 0xb9, 0x68, 0x06, 0x81, 0x36, 0x83, 0x1c, + 0x7d, 0xf8, 0x48, 0xdd, 0x7d, 0xee, 0x48, 0x62, 0x8b, 0xc6, 0x77, 0x85, 0x10, 0xec, 0x21, 0x10, + 0x89, 0xb6, 0xe2, 0x4e, 0x65, 0x98, 0x5d, 0x59, 0xd5, 0x75, 0x87, 0x61, 0x34, 0x75, 0xe8, 0x98, + 0x11, 0x13, 0x03, 0x1c, 0x77, 0xa8, 0x82, 0x68, 0x2f, 0x1b, 0x85, 0x86, 0xdb, 0xd9, 0x2d, 0x71, + 0x6d, 0x3c, 0x00, 0xac, 0x85, 0xd4, 0x48, 0x47, 0x40, 0x33, 0xb8, 0xfe, 0x05, 0xad, 0x71, 0xa3, + 0xf7, 0x9c, 0xe4, 0xa0, 0x4a, 0x5a, 0x55, 0xa9, 0xe3, 0x8e, 0xd9, 0x48, 0x1f, 0xad, 0xbd, 0xff, + 0xee, 0x5e, 0x5f, 0x6a, 0xcb, 0x9c, 0xae, 0x65, 0x45, 0x6f, 0xad, 0x94, 0x3c, 0xb0, 0x5d, 0x93, + 0x5b, 0x59, 0x0f, 0xa2, 0xa8, 0x0b, 0xf0, 0xf8, 0x67, 0xd8, 0x48, 0x9b, 0x42, 0xe1, 0x4c, 0x94, + 0x4f, 0x9f, 0xb2, 0xa0, 0xfe, 0x79, 0x3a, 0xea, 0x16, 0x15, 0xed, 0x35, 0x59, 0x0e, 0x01, 0xb2, + 0x45, 0xc3, 0x29, 0x29, 0x24, 0x81, 0x6c, 0x25, 0x8e, 0x54, 0xa4, 0xd2, 0xc2, 0xcf, 0x88, 0x05, + 0xed, 0x4f, 0x27, 0xb3, 0xb3, 0xf1, 0x8f, 0xe0, 0xbc, 0x55, 0x2e, 0xb0, 0x88, 0x1f, 0x30, 0xbd, + 0xf7, 0x1a, 0xc1, 0x4d, 0x1a, 0x68, 0x67, 0xef, 0xa8, 0xfb, 0x65, 0xe1, 0xfb, 0x62, 0xe6, 0x33, + 0x25, 0x9b, 0x69, 0x47, 0x46, 0x1e, 0xb5, 0x2e, 0x2e, 0x06, 0x14, 0x46, 0x7f, 0x35, 0x2c, 0x4b, + 0x9d, 0x61, 0x15, 0x81, 0x33, 0xe0, 0x3b, 0x6c, 0xad, 0x0a, 0xe4, 0x2f, 0xba, 0x6e, 0x4d, 0x60, + 0x2c, 0x9c, 0x6e, 0x7d, 0x9c, 0x14, 0xea, 0xf5, 0x2d, 0x15, 0xef, 0x2f, 0x78, 0xbd, 0x35, 0xf2, + 0x95, 0x53, 0x6a, 0xec, 0x2d, 0x43, 0x47, 0xe9, 0xb0, 0x13, 0x5a, 0x9b, 0xc7, 0x13, 0x7e, 0x52, + 0x71, 0x0f, 0x03, 0x16, 0xa3, 0xfa, 0x3f, 0xee, 0x4d, 0xdc, 0xdc, 0xa8, 0x47, 0xc7, 0xb1, 0x7e, + 0x2e, 0xea, 0x28, 0x21, 0x9d, 0xd0, 0xf0, 0xfd, 0xa5, 0x14, 0x6b, 0x5e, 0x11, 0x57, 0x13, 0xf3, + 0xfe, 0x1a, 0x9e, 0x62, 0x24, 0xc3, 0xb0, 0x6c, 0x15, 0x73, 0x75, 0xff, 0xe9, 0x28, 0x94, 0x1b, + 0x5f, 0xc0, 0x50, 0xd5, 0x67, 0x19, 0x1f, 0x30, 0xc0, 0x33, 0x68, 0x1a, 0x1f, 0xbc, 0x1d, 0x33, + 0x10, 0x04, 0x83, 0x53, 0xf0, 0x8c, 0x33, 0xcf, 0x7f, 0xc0, 0xad, 0xe3, 0x9f, 0xb0, 0xa7, 0xec, + 0xd0, 0x86, 0x73, 0xd6, 0x2f, 0x00, 0x72, 0xea, 0x3a, 0xc9, 0x1f, 0xf8, 0xb3, 0x6c, 0xcc, 0x58, + 0x11, 0x7c, 0x41, 0x1f, 0xf4, 0x19, 0xbe, 0xf1, 0x30, 0x12, 0x1e, 0xff, 0x4e, 0xf1, 0xd4, 0x61, + 0x63, 0xa9, 0xd8, 0xcd, 0x17, 0x57, 0x1c, 0x4b, 0xe4, 0x77, 0x33, 0xc9, 0xa9, 0xd8, 0xaf, 0x8a, + 0x4b, 0x32, 0x15, 0x3b, 0xa7, 0xa0, 0xad, 0xd6, 0x6b, 0xe4, 0x41, 0x07, 0x24, 0x10, 0x28, 0x99, + 0xaa, 0x6a, 0x7e, 0xb6, 0x6d, 0xb7, 0x1a, 0xa5, 0x5a, 0xb3, 0x54, 0x6e, 0x71, 0x1e, 0xa0, 0x8b, + 0x22, 0xa7, 0x2b, 0x37, 0xd0, 0xe9, 0xae, 0x84, 0xa9, 0x7f, 0x8c, 0xd1, 0xc2, 0x91, 0xf8, 0x31, + 0x8f, 0xc3, 0x65, 0x55, 0xa5, 0xf2, 0x01, 0x71, 0x76, 0xa5, 0xdc, 0x0c, 0xe6, 0x09, 0x0e, 0xba, + 0xb5, 0xec, 0x92, 0xaa, 0x99, 0xcb, 0xdf, 0x10, 0x2f, 0x19, 0x03, 0x36, 0x2a, 0x3b, 0xa5, 0x6a, + 0xad, 0x5a, 0xdb, 0xe2, 0xb4, 0xf9, 0x98, 0x2f, 0xeb, 0x82, 0x38, 0x67, 0x36, 0xa8, 0xd7, 0x77, + 0x72, 0x0b, 0x98, 0x17, 0x28, 0xb6, 0xa8, 0x20, 0x51, 0x30, 0xe5, 0xe7, 0xbd, 0x29, 0xae, 0xa9, + 0x26, 0x7b, 0xb5, 0xc7, 0xb5, 0xfa, 0xe7, 0x35, 0x9d, 0xa2, 0x18, 0xb3, 0x7c, 0xe5, 0x16, 0xcd, + 0x49, 0xa9, 0x16, 0x94, 0x16, 0x78, 0xc9, 0x5c, 0xa5, 0xaa, 0xe1, 0x04, 0x02, 0xe8, 0x14, 0x72, + 0x55, 0x7f, 0x19, 0x46, 0xab, 0x73, 0xce, 0x5e, 0x99, 0xe5, 0x7f, 0xc5, 0xec, 0xa9, 0x36, 0x81, + 0xab, 0xce, 0x59, 0x55, 0xd6, 0xab, 0x4e, 0xb8, 0xc2, 0x81, 0x2f, 0xe8, 0xe9, 0x10, 0x64, 0xfd, + 0x5f, 0x29, 0xf5, 0x72, 0x29, 0x01, 0x66, 0x42, 0xaf, 0xda, 0xce, 0x00, 0x8e, 0x1f, 0x47, 0x53, + 0x96, 0xde, 0x2b, 0x9e, 0x69, 0x6c, 0x95, 0x99, 0x11, 0xc5, 0x31, 0x64, 0xe4, 0xbc, 0x61, 0x60, + 0xc8, 0xa5, 0x02, 0x8a, 0x29, 0x89, 0xf2, 0x38, 0xe3, 0xfc, 0xf5, 0xa9, 0x89, 0x16, 0xc3, 0x61, + 0x6d, 0x82, 0x37, 0xcc, 0xac, 0xa1, 0xff, 0x2f, 0xd2, 0xac, 0xcf, 0x61, 0xeb, 0xcf, 0x43, 0xe7, + 0xa8, 0xfd, 0xdc, 0xf5, 0x54, 0x56, 0x83, 0x09, 0x6f, 0x16, 0x22, 0xda, 0x7f, 0xf2, 0x67, 0xfc, + 0xc2, 0x06, 0x09, 0x26, 0x20, 0x4a, 0x30, 0x4b, 0xdf, 0xd3, 0x16, 0x52, 0xe3, 0xfd, 0x80, 0xdb, + 0x97, 0xd9, 0x15, 0xa4, 0xc8, 0x49, 0x59, 0x36, 0xb9, 0xaa, 0x03, 0x32, 0x40, 0x3f, 0x48, 0x5d, + 0x18, 0xbc, 0x38, 0x60, 0x66, 0x40, 0x32, 0x22, 0xc6, 0x58, 0xd2, 0xbf, 0xdd, 0x51, 0x99, 0xf1, + 0x49, 0xd8, 0xe5, 0xcc, 0x0d, 0xac, 0x1c, 0xd0, 0x09, 0xb8, 0x55, 0xb1, 0x4a, 0xb4, 0x22, 0xf4, + 0x76, 0x92, 0xb8, 0xdb, 0x95, 0xed, 0x17, 0x95, 0x78, 0x84, 0x45, 0x2c, 0x31, 0x2d, 0x2b, 0x01, + 0x4d, 0x46, 0xa5, 0x6c, 0x77, 0x50, 0xa0, 0x00, 0x46, 0xf7, 0x10, 0x3e, 0xdb, 0x45, 0x7e, 0xe0, + 0x2e, 0xc8, 0x3c, 0x57, 0x26, 0x44, 0x22, 0xc1, 0xbb, 0x32, 0x2d, 0x4c, 0x09, 0x60, 0x91, 0xfb, + 0xe2, 0xde, 0xe4, 0x16, 0xdb, 0xee, 0x31, 0xd2, 0x94, 0xd2, 0xf3, 0xb6, 0xdb, 0x6b, 0xef, 0x93, + 0x51, 0x10, 0xb0, 0xcb, 0x6b, 0xe2, 0x95, 0x29, 0x83, 0x1e, 0x1c, 0xe0, 0xdb, 0xf0, 0x5c, 0xfa, + 0xee, 0x13, 0x71, 0x31, 0x29, 0x0c, 0x43, 0xfe, 0x9a, 0x98, 0x18, 0x88, 0x01, 0xe6, 0x03, 0x33, + 0x8e, 0xd7, 0x3e, 0xaa, 0x6e, 0x3d, 0xda, 0x86, 0xff, 0x5a, 0xcd, 0x5c, 0xea, 0xee, 0x7f, 0x93, + 0x12, 0xd7, 0x2a, 0x89, 0xaf, 0x71, 0x25, 0x96, 0xe4, 0xf9, 0x4d, 0x69, 0x81, 0x2b, 0x4f, 0xe5, + 0xdf, 0x11, 0x6f, 0x9d, 0xd2, 0xac, 0xd4, 0x43, 0xef, 0xf8, 0x93, 0x0a, 0x71, 0xdd, 0x80, 0x39, + 0xdf, 0x14, 0xb7, 0x4f, 0xe9, 0x21, 0x1f, 0xed, 0x76, 0x01, 0xa1, 0x9e, 0xde, 0xb8, 0x85, 0xa6, + 0x64, 0x60, 0x54, 0x72, 0xd9, 0xbb, 0x7f, 0x07, 0x72, 0x6b, 0x92, 0x73, 0x8a, 0x3c, 0xc0, 0x89, + 0x6e, 0x2b, 0xb0, 0x61, 0x80, 0x67, 0x27, 0xb4, 0xc0, 0x13, 0x81, 0x75, 0x02, 0x4a, 0x9d, 0xd0, + 0x80, 0xbd, 0x8a, 0x60, 0x61, 0x93, 0xc7, 0xc0, 0xf9, 0xc3, 0x62, 0x26, 0x37, 0x40, 0x86, 0x06, + 0x68, 0xc4, 0xab, 0xe2, 0xc6, 0xc4, 0x79, 0xb2, 0x6f, 0x68, 0x6e, 0xe6, 0xee, 0xaf, 0x67, 0xc5, + 0xe5, 0x09, 0x56, 0x8d, 0x5b, 0xe2, 0x66, 0xc4, 0xf0, 0xa3, 0xeb, 0xec, 0x9a, 0xf3, 0x82, 0xbe, + 0xf2, 0x8d, 0xd3, 0x5a, 0xd1, 0x64, 0x53, 0xf9, 0xb7, 0xc5, 0x9b, 0x13, 0x5b, 0x61, 0x93, 0xa6, + 0x03, 0x7c, 0x83, 0x16, 0x88, 0x60, 0xf9, 0x6f, 0x89, 0x37, 0xa6, 0x76, 0x30, 0x5b, 0x67, 0xe4, + 0x7e, 0x26, 0xb7, 0x7e, 0x04, 0x2b, 0x86, 0xdd, 0x78, 0x43, 0xdc, 0x9a, 0xdc, 0x04, 0x7e, 0x7d, + 0xee, 0xf6, 0xb7, 0x3d, 0x10, 0x66, 0x67, 0xe4, 0xf5, 0x4b, 0x6e, 0xb9, 0x49, 0x6f, 0x81, 0xfa, + 0xa3, 0xde, 0x49, 0x10, 0xe6, 0x3c, 0x37, 0x9b, 0xbf, 0x23, 0x5e, 0x9b, 0xdc, 0xc5, 0x88, 0xa3, + 0x0a, 0x34, 0x78, 0xda, 0x3c, 0x76, 0xbd, 0xc1, 0xb8, 0xd7, 0x1e, 0x52, 0xcb, 0x79, 0x79, 0x67, + 0x92, 0x5b, 0x36, 0xdb, 0x3d, 0x7a, 0x86, 0x0e, 0xe4, 0x79, 0xda, 0xb7, 0xb1, 0x19, 0x88, 0xe1, + 0x84, 0xca, 0x80, 0x4c, 0xbf, 0x2e, 0xac, 0x89, 0x4d, 0xcb, 0x1e, 0xe5, 0x3f, 0x73, 0x86, 0xb9, + 0xc5, 0xbb, 0xbf, 0x98, 0x11, 0x97, 0x12, 0x2d, 0x7e, 0x98, 0x69, 0x70, 0xba, 0x31, 0x10, 0x20, + 0x82, 0xe1, 0x2e, 0xb1, 0x8d, 0x7c, 0x39, 0x0f, 0x00, 0x11, 0x9f, 0x4a, 0x30, 0x10, 0xfc, 0xd3, + 0x24, 0xd5, 0x24, 0xc0, 0xc1, 0x5d, 0xf1, 0xfa, 0xa4, 0x76, 0xa4, 0x99, 0x6d, 0x29, 0xc9, 0x52, + 0x5f, 0xef, 0xc4, 0xb6, 0x95, 0x2f, 0x07, 0x20, 0xe1, 0x06, 0x8d, 0xb3, 0x09, 0x70, 0x1b, 0x5a, + 0x09, 0x80, 0x03, 0xc2, 0xc2, 0xb4, 0x69, 0xc2, 0x8f, 0x6d, 0x0a, 0x14, 0x01, 0x00, 0x10, 0x3f, + 0xd5, 0x60, 0x9a, 0xe6, 0x19, 0xcc, 0x25, 0x00, 0xb6, 0x6e, 0xa9, 0x8f, 0x40, 0x6d, 0xd3, 0xfc, + 0xdd, 0x1f, 0xe2, 0x49, 0x24, 0x99, 0x26, 0x50, 0xe5, 0x32, 0xd9, 0x6a, 0x01, 0xa7, 0xc0, 0x1b, + 0x97, 0x58, 0xcf, 0x79, 0x9b, 0xec, 0xad, 0x4a, 0xad, 0xd2, 0xa8, 0x96, 0xf5, 0x61, 0x24, 0xb6, + 0x45, 0xa6, 0x4b, 0xe6, 0xfe, 0x54, 0x97, 0x32, 0xb1, 0x9d, 0xce, 0x15, 0x89, 0xc4, 0x01, 0x93, + 0x7c, 0x66, 0xce, 0xd4, 0xba, 0x5c, 0x2f, 0x95, 0x1f, 0x55, 0x30, 0x69, 0x28, 0x1f, 0x5e, 0x62, + 0xeb, 0x4a, 0x6d, 0xab, 0x5a, 0xab, 0xd8, 0xc0, 0xfd, 0x52, 0x2a, 0x1e, 0x38, 0x16, 0x86, 0xf9, + 0x09, 0x13, 0xb6, 0x81, 0x1f, 0x7f, 0x64, 0x6f, 0x35, 0xea, 0x7b, 0xbb, 0x70, 0x32, 0x4c, 0x52, + 0x92, 0xf7, 0x89, 0x32, 0x9b, 0x52, 0x43, 0x5a, 0x67, 0x7d, 0xb7, 0x52, 0x83, 0x13, 0x9a, 0x32, + 0x93, 0x68, 0x7a, 0xce, 0xf9, 0xfc, 0x6d, 0xf1, 0xea, 0xb4, 0xad, 0x53, 0x0d, 0x17, 0x1e, 0xce, + 0x3c, 0x4a, 0xfd, 0x7c, 0xea, 0x1b, 0xff, 0x22, 0x00, 0x00, 0xff, 0xff, 0x5f, 0xc4, 0xa6, 0x8b, + 0x4b, 0xd8, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_client_fantasy.pb.go b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_client_fantasy.pb.go new file mode 100644 index 00000000..e86898f3 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_client_fantasy.pb.go @@ -0,0 +1,6123 @@ +// Code generated by protoc-gen-go. +// source: dota_gcmessages_client_fantasy.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 protobuf is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type ETournamentGameState int32 + +const ( + ETournamentGameState_k_ETournamentGameState_Unknown ETournamentGameState = 0 + ETournamentGameState_k_ETournamentGameState_Scheduled ETournamentGameState = 1 + ETournamentGameState_k_ETournamentGameState_WaitingForLobbyToStart ETournamentGameState = 2 + ETournamentGameState_k_ETournamentGameState_Active ETournamentGameState = 3 + ETournamentGameState_k_ETournamentGameState_DireVictory ETournamentGameState = 4 + ETournamentGameState_k_ETournamentGameState_RadVictory ETournamentGameState = 5 + ETournamentGameState_k_ETournamentGameState_Canceled ETournamentGameState = 6 + ETournamentGameState_k_ETournamentTeamState_NotNeeded ETournamentGameState = 7 +) + +var ETournamentGameState_name = map[int32]string{ + 0: "k_ETournamentGameState_Unknown", + 1: "k_ETournamentGameState_Scheduled", + 2: "k_ETournamentGameState_WaitingForLobbyToStart", + 3: "k_ETournamentGameState_Active", + 4: "k_ETournamentGameState_DireVictory", + 5: "k_ETournamentGameState_RadVictory", + 6: "k_ETournamentGameState_Canceled", + 7: "k_ETournamentTeamState_NotNeeded", +} +var ETournamentGameState_value = map[string]int32{ + "k_ETournamentGameState_Unknown": 0, + "k_ETournamentGameState_Scheduled": 1, + "k_ETournamentGameState_WaitingForLobbyToStart": 2, + "k_ETournamentGameState_Active": 3, + "k_ETournamentGameState_DireVictory": 4, + "k_ETournamentGameState_RadVictory": 5, + "k_ETournamentGameState_Canceled": 6, + "k_ETournamentTeamState_NotNeeded": 7, +} + +func (x ETournamentGameState) Enum() *ETournamentGameState { + p := new(ETournamentGameState) + *p = x + return p +} +func (x ETournamentGameState) String() string { + return proto.EnumName(ETournamentGameState_name, int32(x)) +} +func (x *ETournamentGameState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ETournamentGameState_value, data, "ETournamentGameState") + if err != nil { + return err + } + *x = ETournamentGameState(value) + return nil +} +func (ETournamentGameState) EnumDescriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{0} } + +type ETournamentTeamState int32 + +const ( + ETournamentTeamState_k_ETournamentTeamState_Unknown ETournamentTeamState = 0 + ETournamentTeamState_k_ETournamentTeamState_Node1 ETournamentTeamState = 1 + ETournamentTeamState_k_ETournamentTeamState_NodeMax ETournamentTeamState = 1024 + ETournamentTeamState_k_ETournamentTeamState_Eliminated ETournamentTeamState = 14003 + ETournamentTeamState_k_ETournamentTeamState_Forfeited ETournamentTeamState = 14004 + ETournamentTeamState_k_ETournamentTeamState_Finished1st ETournamentTeamState = 15001 + ETournamentTeamState_k_ETournamentTeamState_Finished2nd ETournamentTeamState = 15002 + ETournamentTeamState_k_ETournamentTeamState_Finished3rd ETournamentTeamState = 15003 + ETournamentTeamState_k_ETournamentTeamState_Finished4th ETournamentTeamState = 15004 + ETournamentTeamState_k_ETournamentTeamState_Finished5th ETournamentTeamState = 15005 + ETournamentTeamState_k_ETournamentTeamState_Finished6th ETournamentTeamState = 15006 + ETournamentTeamState_k_ETournamentTeamState_Finished7th ETournamentTeamState = 15007 + ETournamentTeamState_k_ETournamentTeamState_Finished8th ETournamentTeamState = 15008 + ETournamentTeamState_k_ETournamentTeamState_Finished9th ETournamentTeamState = 15009 + ETournamentTeamState_k_ETournamentTeamState_Finished10th ETournamentTeamState = 15010 + ETournamentTeamState_k_ETournamentTeamState_Finished11th ETournamentTeamState = 15011 + ETournamentTeamState_k_ETournamentTeamState_Finished12th ETournamentTeamState = 15012 + ETournamentTeamState_k_ETournamentTeamState_Finished13th ETournamentTeamState = 15013 + ETournamentTeamState_k_ETournamentTeamState_Finished14th ETournamentTeamState = 15014 + ETournamentTeamState_k_ETournamentTeamState_Finished15th ETournamentTeamState = 15015 + ETournamentTeamState_k_ETournamentTeamState_Finished16th ETournamentTeamState = 15016 +) + +var ETournamentTeamState_name = map[int32]string{ + 0: "k_ETournamentTeamState_Unknown", + 1: "k_ETournamentTeamState_Node1", + 1024: "k_ETournamentTeamState_NodeMax", + 14003: "k_ETournamentTeamState_Eliminated", + 14004: "k_ETournamentTeamState_Forfeited", + 15001: "k_ETournamentTeamState_Finished1st", + 15002: "k_ETournamentTeamState_Finished2nd", + 15003: "k_ETournamentTeamState_Finished3rd", + 15004: "k_ETournamentTeamState_Finished4th", + 15005: "k_ETournamentTeamState_Finished5th", + 15006: "k_ETournamentTeamState_Finished6th", + 15007: "k_ETournamentTeamState_Finished7th", + 15008: "k_ETournamentTeamState_Finished8th", + 15009: "k_ETournamentTeamState_Finished9th", + 15010: "k_ETournamentTeamState_Finished10th", + 15011: "k_ETournamentTeamState_Finished11th", + 15012: "k_ETournamentTeamState_Finished12th", + 15013: "k_ETournamentTeamState_Finished13th", + 15014: "k_ETournamentTeamState_Finished14th", + 15015: "k_ETournamentTeamState_Finished15th", + 15016: "k_ETournamentTeamState_Finished16th", +} +var ETournamentTeamState_value = map[string]int32{ + "k_ETournamentTeamState_Unknown": 0, + "k_ETournamentTeamState_Node1": 1, + "k_ETournamentTeamState_NodeMax": 1024, + "k_ETournamentTeamState_Eliminated": 14003, + "k_ETournamentTeamState_Forfeited": 14004, + "k_ETournamentTeamState_Finished1st": 15001, + "k_ETournamentTeamState_Finished2nd": 15002, + "k_ETournamentTeamState_Finished3rd": 15003, + "k_ETournamentTeamState_Finished4th": 15004, + "k_ETournamentTeamState_Finished5th": 15005, + "k_ETournamentTeamState_Finished6th": 15006, + "k_ETournamentTeamState_Finished7th": 15007, + "k_ETournamentTeamState_Finished8th": 15008, + "k_ETournamentTeamState_Finished9th": 15009, + "k_ETournamentTeamState_Finished10th": 15010, + "k_ETournamentTeamState_Finished11th": 15011, + "k_ETournamentTeamState_Finished12th": 15012, + "k_ETournamentTeamState_Finished13th": 15013, + "k_ETournamentTeamState_Finished14th": 15014, + "k_ETournamentTeamState_Finished15th": 15015, + "k_ETournamentTeamState_Finished16th": 15016, +} + +func (x ETournamentTeamState) Enum() *ETournamentTeamState { + p := new(ETournamentTeamState) + *p = x + return p +} +func (x ETournamentTeamState) String() string { + return proto.EnumName(ETournamentTeamState_name, int32(x)) +} +func (x *ETournamentTeamState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ETournamentTeamState_value, data, "ETournamentTeamState") + if err != nil { + return err + } + *x = ETournamentTeamState(value) + return nil +} +func (ETournamentTeamState) EnumDescriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{1} } + +type ETournamentState int32 + +const ( + ETournamentState_k_ETournamentState_Unknown ETournamentState = 0 + ETournamentState_k_ETournamentState_Setup ETournamentState = 1 + ETournamentState_k_ETournamentState_Scheduled ETournamentState = 2 + ETournamentState_k_ETournamentState_InProgress ETournamentState = 3 + ETournamentState_k_ETournamentState_Completed ETournamentState = 4 + ETournamentState_k_ETournamentState_Canceled ETournamentState = 5 +) + +var ETournamentState_name = map[int32]string{ + 0: "k_ETournamentState_Unknown", + 1: "k_ETournamentState_Setup", + 2: "k_ETournamentState_Scheduled", + 3: "k_ETournamentState_InProgress", + 4: "k_ETournamentState_Completed", + 5: "k_ETournamentState_Canceled", +} +var ETournamentState_value = map[string]int32{ + "k_ETournamentState_Unknown": 0, + "k_ETournamentState_Setup": 1, + "k_ETournamentState_Scheduled": 2, + "k_ETournamentState_InProgress": 3, + "k_ETournamentState_Completed": 4, + "k_ETournamentState_Canceled": 5, +} + +func (x ETournamentState) Enum() *ETournamentState { + p := new(ETournamentState) + *p = x + return p +} +func (x ETournamentState) String() string { + return proto.EnumName(ETournamentState_name, int32(x)) +} +func (x *ETournamentState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ETournamentState_value, data, "ETournamentState") + if err != nil { + return err + } + *x = ETournamentState(value) + return nil +} +func (ETournamentState) EnumDescriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{2} } + +type ETournamentNodeState int32 + +const ( + ETournamentNodeState_k_ETournamentNodeState_Unknown ETournamentNodeState = 0 + ETournamentNodeState_k_ETournamentNodeState_TeamsNotYetAssigned ETournamentNodeState = 1 + ETournamentNodeState_k_ETournamentNodeState_InBetweenGames ETournamentNodeState = 2 + ETournamentNodeState_k_ETournamentNodeState_GameInProgress ETournamentNodeState = 3 + ETournamentNodeState_k_ETournamentNodeState_A_Won ETournamentNodeState = 4 + ETournamentNodeState_k_ETournamentNodeState_B_Won ETournamentNodeState = 5 + ETournamentNodeState_k_ETournamentNodeState_Canceled ETournamentNodeState = 6 +) + +var ETournamentNodeState_name = map[int32]string{ + 0: "k_ETournamentNodeState_Unknown", + 1: "k_ETournamentNodeState_TeamsNotYetAssigned", + 2: "k_ETournamentNodeState_InBetweenGames", + 3: "k_ETournamentNodeState_GameInProgress", + 4: "k_ETournamentNodeState_A_Won", + 5: "k_ETournamentNodeState_B_Won", + 6: "k_ETournamentNodeState_Canceled", +} +var ETournamentNodeState_value = map[string]int32{ + "k_ETournamentNodeState_Unknown": 0, + "k_ETournamentNodeState_TeamsNotYetAssigned": 1, + "k_ETournamentNodeState_InBetweenGames": 2, + "k_ETournamentNodeState_GameInProgress": 3, + "k_ETournamentNodeState_A_Won": 4, + "k_ETournamentNodeState_B_Won": 5, + "k_ETournamentNodeState_Canceled": 6, +} + +func (x ETournamentNodeState) Enum() *ETournamentNodeState { + p := new(ETournamentNodeState) + *p = x + return p +} +func (x ETournamentNodeState) String() string { + return proto.EnumName(ETournamentNodeState_name, int32(x)) +} +func (x *ETournamentNodeState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ETournamentNodeState_value, data, "ETournamentNodeState") + if err != nil { + return err + } + *x = ETournamentNodeState(value) + return nil +} +func (ETournamentNodeState) EnumDescriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{3} } + +type DOTA_2013PassportSelectionIndices int32 + +const ( + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_0 DOTA_2013PassportSelectionIndices = 0 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_1 DOTA_2013PassportSelectionIndices = 1 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_2 DOTA_2013PassportSelectionIndices = 2 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_3 DOTA_2013PassportSelectionIndices = 3 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_4 DOTA_2013PassportSelectionIndices = 4 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_5 DOTA_2013PassportSelectionIndices = 5 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_6 DOTA_2013PassportSelectionIndices = 6 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_7 DOTA_2013PassportSelectionIndices = 7 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_8 DOTA_2013PassportSelectionIndices = 8 + DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_9 DOTA_2013PassportSelectionIndices = 9 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_0 DOTA_2013PassportSelectionIndices = 10 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_1 DOTA_2013PassportSelectionIndices = 11 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_2 DOTA_2013PassportSelectionIndices = 12 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_3 DOTA_2013PassportSelectionIndices = 13 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_4 DOTA_2013PassportSelectionIndices = 14 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_5 DOTA_2013PassportSelectionIndices = 15 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_6 DOTA_2013PassportSelectionIndices = 16 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_7 DOTA_2013PassportSelectionIndices = 17 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_8 DOTA_2013PassportSelectionIndices = 18 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_9 DOTA_2013PassportSelectionIndices = 19 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_10 DOTA_2013PassportSelectionIndices = 20 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_11 DOTA_2013PassportSelectionIndices = 21 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_12 DOTA_2013PassportSelectionIndices = 22 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_13 DOTA_2013PassportSelectionIndices = 23 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_WEST_14 DOTA_2013PassportSelectionIndices = 24 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_0 DOTA_2013PassportSelectionIndices = 25 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_1 DOTA_2013PassportSelectionIndices = 26 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_2 DOTA_2013PassportSelectionIndices = 27 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_3 DOTA_2013PassportSelectionIndices = 28 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_4 DOTA_2013PassportSelectionIndices = 29 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_5 DOTA_2013PassportSelectionIndices = 30 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_6 DOTA_2013PassportSelectionIndices = 31 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_7 DOTA_2013PassportSelectionIndices = 32 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_8 DOTA_2013PassportSelectionIndices = 33 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_9 DOTA_2013PassportSelectionIndices = 34 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_10 DOTA_2013PassportSelectionIndices = 35 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_11 DOTA_2013PassportSelectionIndices = 36 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_12 DOTA_2013PassportSelectionIndices = 37 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_13 DOTA_2013PassportSelectionIndices = 38 + DOTA_2013PassportSelectionIndices_PP13_SEL_QUALPRED_EAST_14 DOTA_2013PassportSelectionIndices = 39 + DOTA_2013PassportSelectionIndices_PP13_SEL_TEAMCUP_TEAM DOTA_2013PassportSelectionIndices = 40 + DOTA_2013PassportSelectionIndices_PP13_SEL_TEAMCUP_PLAYER DOTA_2013PassportSelectionIndices = 41 + DOTA_2013PassportSelectionIndices_PP13_SEL_TEAMCUP_TEAM_LOCK DOTA_2013PassportSelectionIndices = 42 + DOTA_2013PassportSelectionIndices_PP13_SEL_TEAMCUP_PLAYER_LOCK DOTA_2013PassportSelectionIndices = 43 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_0 DOTA_2013PassportSelectionIndices = 44 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_1 DOTA_2013PassportSelectionIndices = 45 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_2 DOTA_2013PassportSelectionIndices = 46 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_3 DOTA_2013PassportSelectionIndices = 47 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_4 DOTA_2013PassportSelectionIndices = 48 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_5 DOTA_2013PassportSelectionIndices = 49 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_6 DOTA_2013PassportSelectionIndices = 50 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_7 DOTA_2013PassportSelectionIndices = 51 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_8 DOTA_2013PassportSelectionIndices = 52 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_9 DOTA_2013PassportSelectionIndices = 53 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_10 DOTA_2013PassportSelectionIndices = 54 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_11 DOTA_2013PassportSelectionIndices = 55 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_12 DOTA_2013PassportSelectionIndices = 56 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_13 DOTA_2013PassportSelectionIndices = 57 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_14 DOTA_2013PassportSelectionIndices = 58 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_15 DOTA_2013PassportSelectionIndices = 59 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_16 DOTA_2013PassportSelectionIndices = 60 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_17 DOTA_2013PassportSelectionIndices = 61 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_18 DOTA_2013PassportSelectionIndices = 62 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_19 DOTA_2013PassportSelectionIndices = 63 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_20 DOTA_2013PassportSelectionIndices = 64 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_21 DOTA_2013PassportSelectionIndices = 65 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_22 DOTA_2013PassportSelectionIndices = 66 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_23 DOTA_2013PassportSelectionIndices = 67 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_24 DOTA_2013PassportSelectionIndices = 68 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_25 DOTA_2013PassportSelectionIndices = 69 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_26 DOTA_2013PassportSelectionIndices = 70 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_27 DOTA_2013PassportSelectionIndices = 71 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_28 DOTA_2013PassportSelectionIndices = 72 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_29 DOTA_2013PassportSelectionIndices = 73 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_30 DOTA_2013PassportSelectionIndices = 74 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_31 DOTA_2013PassportSelectionIndices = 75 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_32 DOTA_2013PassportSelectionIndices = 76 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_33 DOTA_2013PassportSelectionIndices = 77 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_34 DOTA_2013PassportSelectionIndices = 78 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_35 DOTA_2013PassportSelectionIndices = 79 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_36 DOTA_2013PassportSelectionIndices = 80 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_37 DOTA_2013PassportSelectionIndices = 81 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_38 DOTA_2013PassportSelectionIndices = 82 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_39 DOTA_2013PassportSelectionIndices = 83 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_40 DOTA_2013PassportSelectionIndices = 84 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_41 DOTA_2013PassportSelectionIndices = 85 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_42 DOTA_2013PassportSelectionIndices = 86 + DOTA_2013PassportSelectionIndices_PP13_SEL_EVENTPRED_43 DOTA_2013PassportSelectionIndices = 87 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_0 DOTA_2013PassportSelectionIndices = 88 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_1 DOTA_2013PassportSelectionIndices = 89 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_2 DOTA_2013PassportSelectionIndices = 90 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_3 DOTA_2013PassportSelectionIndices = 91 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_4 DOTA_2013PassportSelectionIndices = 92 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_5 DOTA_2013PassportSelectionIndices = 93 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_6 DOTA_2013PassportSelectionIndices = 94 + DOTA_2013PassportSelectionIndices_PP13_SEL_SOLO_7 DOTA_2013PassportSelectionIndices = 95 +) + +var DOTA_2013PassportSelectionIndices_name = map[int32]string{ + 0: "PP13_SEL_ALLSTAR_PLAYER_0", + 1: "PP13_SEL_ALLSTAR_PLAYER_1", + 2: "PP13_SEL_ALLSTAR_PLAYER_2", + 3: "PP13_SEL_ALLSTAR_PLAYER_3", + 4: "PP13_SEL_ALLSTAR_PLAYER_4", + 5: "PP13_SEL_ALLSTAR_PLAYER_5", + 6: "PP13_SEL_ALLSTAR_PLAYER_6", + 7: "PP13_SEL_ALLSTAR_PLAYER_7", + 8: "PP13_SEL_ALLSTAR_PLAYER_8", + 9: "PP13_SEL_ALLSTAR_PLAYER_9", + 10: "PP13_SEL_QUALPRED_WEST_0", + 11: "PP13_SEL_QUALPRED_WEST_1", + 12: "PP13_SEL_QUALPRED_WEST_2", + 13: "PP13_SEL_QUALPRED_WEST_3", + 14: "PP13_SEL_QUALPRED_WEST_4", + 15: "PP13_SEL_QUALPRED_WEST_5", + 16: "PP13_SEL_QUALPRED_WEST_6", + 17: "PP13_SEL_QUALPRED_WEST_7", + 18: "PP13_SEL_QUALPRED_WEST_8", + 19: "PP13_SEL_QUALPRED_WEST_9", + 20: "PP13_SEL_QUALPRED_WEST_10", + 21: "PP13_SEL_QUALPRED_WEST_11", + 22: "PP13_SEL_QUALPRED_WEST_12", + 23: "PP13_SEL_QUALPRED_WEST_13", + 24: "PP13_SEL_QUALPRED_WEST_14", + 25: "PP13_SEL_QUALPRED_EAST_0", + 26: "PP13_SEL_QUALPRED_EAST_1", + 27: "PP13_SEL_QUALPRED_EAST_2", + 28: "PP13_SEL_QUALPRED_EAST_3", + 29: "PP13_SEL_QUALPRED_EAST_4", + 30: "PP13_SEL_QUALPRED_EAST_5", + 31: "PP13_SEL_QUALPRED_EAST_6", + 32: "PP13_SEL_QUALPRED_EAST_7", + 33: "PP13_SEL_QUALPRED_EAST_8", + 34: "PP13_SEL_QUALPRED_EAST_9", + 35: "PP13_SEL_QUALPRED_EAST_10", + 36: "PP13_SEL_QUALPRED_EAST_11", + 37: "PP13_SEL_QUALPRED_EAST_12", + 38: "PP13_SEL_QUALPRED_EAST_13", + 39: "PP13_SEL_QUALPRED_EAST_14", + 40: "PP13_SEL_TEAMCUP_TEAM", + 41: "PP13_SEL_TEAMCUP_PLAYER", + 42: "PP13_SEL_TEAMCUP_TEAM_LOCK", + 43: "PP13_SEL_TEAMCUP_PLAYER_LOCK", + 44: "PP13_SEL_EVENTPRED_0", + 45: "PP13_SEL_EVENTPRED_1", + 46: "PP13_SEL_EVENTPRED_2", + 47: "PP13_SEL_EVENTPRED_3", + 48: "PP13_SEL_EVENTPRED_4", + 49: "PP13_SEL_EVENTPRED_5", + 50: "PP13_SEL_EVENTPRED_6", + 51: "PP13_SEL_EVENTPRED_7", + 52: "PP13_SEL_EVENTPRED_8", + 53: "PP13_SEL_EVENTPRED_9", + 54: "PP13_SEL_EVENTPRED_10", + 55: "PP13_SEL_EVENTPRED_11", + 56: "PP13_SEL_EVENTPRED_12", + 57: "PP13_SEL_EVENTPRED_13", + 58: "PP13_SEL_EVENTPRED_14", + 59: "PP13_SEL_EVENTPRED_15", + 60: "PP13_SEL_EVENTPRED_16", + 61: "PP13_SEL_EVENTPRED_17", + 62: "PP13_SEL_EVENTPRED_18", + 63: "PP13_SEL_EVENTPRED_19", + 64: "PP13_SEL_EVENTPRED_20", + 65: "PP13_SEL_EVENTPRED_21", + 66: "PP13_SEL_EVENTPRED_22", + 67: "PP13_SEL_EVENTPRED_23", + 68: "PP13_SEL_EVENTPRED_24", + 69: "PP13_SEL_EVENTPRED_25", + 70: "PP13_SEL_EVENTPRED_26", + 71: "PP13_SEL_EVENTPRED_27", + 72: "PP13_SEL_EVENTPRED_28", + 73: "PP13_SEL_EVENTPRED_29", + 74: "PP13_SEL_EVENTPRED_30", + 75: "PP13_SEL_EVENTPRED_31", + 76: "PP13_SEL_EVENTPRED_32", + 77: "PP13_SEL_EVENTPRED_33", + 78: "PP13_SEL_EVENTPRED_34", + 79: "PP13_SEL_EVENTPRED_35", + 80: "PP13_SEL_EVENTPRED_36", + 81: "PP13_SEL_EVENTPRED_37", + 82: "PP13_SEL_EVENTPRED_38", + 83: "PP13_SEL_EVENTPRED_39", + 84: "PP13_SEL_EVENTPRED_40", + 85: "PP13_SEL_EVENTPRED_41", + 86: "PP13_SEL_EVENTPRED_42", + 87: "PP13_SEL_EVENTPRED_43", + 88: "PP13_SEL_SOLO_0", + 89: "PP13_SEL_SOLO_1", + 90: "PP13_SEL_SOLO_2", + 91: "PP13_SEL_SOLO_3", + 92: "PP13_SEL_SOLO_4", + 93: "PP13_SEL_SOLO_5", + 94: "PP13_SEL_SOLO_6", + 95: "PP13_SEL_SOLO_7", +} +var DOTA_2013PassportSelectionIndices_value = map[string]int32{ + "PP13_SEL_ALLSTAR_PLAYER_0": 0, + "PP13_SEL_ALLSTAR_PLAYER_1": 1, + "PP13_SEL_ALLSTAR_PLAYER_2": 2, + "PP13_SEL_ALLSTAR_PLAYER_3": 3, + "PP13_SEL_ALLSTAR_PLAYER_4": 4, + "PP13_SEL_ALLSTAR_PLAYER_5": 5, + "PP13_SEL_ALLSTAR_PLAYER_6": 6, + "PP13_SEL_ALLSTAR_PLAYER_7": 7, + "PP13_SEL_ALLSTAR_PLAYER_8": 8, + "PP13_SEL_ALLSTAR_PLAYER_9": 9, + "PP13_SEL_QUALPRED_WEST_0": 10, + "PP13_SEL_QUALPRED_WEST_1": 11, + "PP13_SEL_QUALPRED_WEST_2": 12, + "PP13_SEL_QUALPRED_WEST_3": 13, + "PP13_SEL_QUALPRED_WEST_4": 14, + "PP13_SEL_QUALPRED_WEST_5": 15, + "PP13_SEL_QUALPRED_WEST_6": 16, + "PP13_SEL_QUALPRED_WEST_7": 17, + "PP13_SEL_QUALPRED_WEST_8": 18, + "PP13_SEL_QUALPRED_WEST_9": 19, + "PP13_SEL_QUALPRED_WEST_10": 20, + "PP13_SEL_QUALPRED_WEST_11": 21, + "PP13_SEL_QUALPRED_WEST_12": 22, + "PP13_SEL_QUALPRED_WEST_13": 23, + "PP13_SEL_QUALPRED_WEST_14": 24, + "PP13_SEL_QUALPRED_EAST_0": 25, + "PP13_SEL_QUALPRED_EAST_1": 26, + "PP13_SEL_QUALPRED_EAST_2": 27, + "PP13_SEL_QUALPRED_EAST_3": 28, + "PP13_SEL_QUALPRED_EAST_4": 29, + "PP13_SEL_QUALPRED_EAST_5": 30, + "PP13_SEL_QUALPRED_EAST_6": 31, + "PP13_SEL_QUALPRED_EAST_7": 32, + "PP13_SEL_QUALPRED_EAST_8": 33, + "PP13_SEL_QUALPRED_EAST_9": 34, + "PP13_SEL_QUALPRED_EAST_10": 35, + "PP13_SEL_QUALPRED_EAST_11": 36, + "PP13_SEL_QUALPRED_EAST_12": 37, + "PP13_SEL_QUALPRED_EAST_13": 38, + "PP13_SEL_QUALPRED_EAST_14": 39, + "PP13_SEL_TEAMCUP_TEAM": 40, + "PP13_SEL_TEAMCUP_PLAYER": 41, + "PP13_SEL_TEAMCUP_TEAM_LOCK": 42, + "PP13_SEL_TEAMCUP_PLAYER_LOCK": 43, + "PP13_SEL_EVENTPRED_0": 44, + "PP13_SEL_EVENTPRED_1": 45, + "PP13_SEL_EVENTPRED_2": 46, + "PP13_SEL_EVENTPRED_3": 47, + "PP13_SEL_EVENTPRED_4": 48, + "PP13_SEL_EVENTPRED_5": 49, + "PP13_SEL_EVENTPRED_6": 50, + "PP13_SEL_EVENTPRED_7": 51, + "PP13_SEL_EVENTPRED_8": 52, + "PP13_SEL_EVENTPRED_9": 53, + "PP13_SEL_EVENTPRED_10": 54, + "PP13_SEL_EVENTPRED_11": 55, + "PP13_SEL_EVENTPRED_12": 56, + "PP13_SEL_EVENTPRED_13": 57, + "PP13_SEL_EVENTPRED_14": 58, + "PP13_SEL_EVENTPRED_15": 59, + "PP13_SEL_EVENTPRED_16": 60, + "PP13_SEL_EVENTPRED_17": 61, + "PP13_SEL_EVENTPRED_18": 62, + "PP13_SEL_EVENTPRED_19": 63, + "PP13_SEL_EVENTPRED_20": 64, + "PP13_SEL_EVENTPRED_21": 65, + "PP13_SEL_EVENTPRED_22": 66, + "PP13_SEL_EVENTPRED_23": 67, + "PP13_SEL_EVENTPRED_24": 68, + "PP13_SEL_EVENTPRED_25": 69, + "PP13_SEL_EVENTPRED_26": 70, + "PP13_SEL_EVENTPRED_27": 71, + "PP13_SEL_EVENTPRED_28": 72, + "PP13_SEL_EVENTPRED_29": 73, + "PP13_SEL_EVENTPRED_30": 74, + "PP13_SEL_EVENTPRED_31": 75, + "PP13_SEL_EVENTPRED_32": 76, + "PP13_SEL_EVENTPRED_33": 77, + "PP13_SEL_EVENTPRED_34": 78, + "PP13_SEL_EVENTPRED_35": 79, + "PP13_SEL_EVENTPRED_36": 80, + "PP13_SEL_EVENTPRED_37": 81, + "PP13_SEL_EVENTPRED_38": 82, + "PP13_SEL_EVENTPRED_39": 83, + "PP13_SEL_EVENTPRED_40": 84, + "PP13_SEL_EVENTPRED_41": 85, + "PP13_SEL_EVENTPRED_42": 86, + "PP13_SEL_EVENTPRED_43": 87, + "PP13_SEL_SOLO_0": 88, + "PP13_SEL_SOLO_1": 89, + "PP13_SEL_SOLO_2": 90, + "PP13_SEL_SOLO_3": 91, + "PP13_SEL_SOLO_4": 92, + "PP13_SEL_SOLO_5": 93, + "PP13_SEL_SOLO_6": 94, + "PP13_SEL_SOLO_7": 95, +} + +func (x DOTA_2013PassportSelectionIndices) Enum() *DOTA_2013PassportSelectionIndices { + p := new(DOTA_2013PassportSelectionIndices) + *p = x + return p +} +func (x DOTA_2013PassportSelectionIndices) String() string { + return proto.EnumName(DOTA_2013PassportSelectionIndices_name, int32(x)) +} +func (x *DOTA_2013PassportSelectionIndices) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_2013PassportSelectionIndices_value, data, "DOTA_2013PassportSelectionIndices") + if err != nil { + return err + } + *x = DOTA_2013PassportSelectionIndices(value) + return nil +} +func (DOTA_2013PassportSelectionIndices) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{4} +} + +type CMsgDOTACreateFantasyLeagueResponse_EResult int32 + +const ( + CMsgDOTACreateFantasyLeagueResponse_SUCCESS CMsgDOTACreateFantasyLeagueResponse_EResult = 0 + CMsgDOTACreateFantasyLeagueResponse_ERROR_UNSPECIFIED CMsgDOTACreateFantasyLeagueResponse_EResult = 1 + CMsgDOTACreateFantasyLeagueResponse_ERROR_TOO_MANY_LEAGUES CMsgDOTACreateFantasyLeagueResponse_EResult = 2 + CMsgDOTACreateFantasyLeagueResponse_ERROR_INVALID_TEAM_COUNT CMsgDOTACreateFantasyLeagueResponse_EResult = 3 + CMsgDOTACreateFantasyLeagueResponse_ERROR_CREATION_DISABLED CMsgDOTACreateFantasyLeagueResponse_EResult = 4 +) + +var CMsgDOTACreateFantasyLeagueResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_TOO_MANY_LEAGUES", + 3: "ERROR_INVALID_TEAM_COUNT", + 4: "ERROR_CREATION_DISABLED", +} +var CMsgDOTACreateFantasyLeagueResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_TOO_MANY_LEAGUES": 2, + "ERROR_INVALID_TEAM_COUNT": 3, + "ERROR_CREATION_DISABLED": 4, +} + +func (x CMsgDOTACreateFantasyLeagueResponse_EResult) Enum() *CMsgDOTACreateFantasyLeagueResponse_EResult { + p := new(CMsgDOTACreateFantasyLeagueResponse_EResult) + *p = x + return p +} +func (x CMsgDOTACreateFantasyLeagueResponse_EResult) String() string { + return proto.EnumName(CMsgDOTACreateFantasyLeagueResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTACreateFantasyLeagueResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTACreateFantasyLeagueResponse_EResult_value, data, "CMsgDOTACreateFantasyLeagueResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTACreateFantasyLeagueResponse_EResult(value) + return nil +} +func (CMsgDOTACreateFantasyLeagueResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{2, 0} +} + +type CMsgDOTAFantasyLeagueEditInfoResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeagueEditInfoResponse_SUCCESS CMsgDOTAFantasyLeagueEditInfoResponse_EResult = 0 + CMsgDOTAFantasyLeagueEditInfoResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeagueEditInfoResponse_EResult = 1 + CMsgDOTAFantasyLeagueEditInfoResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyLeagueEditInfoResponse_EResult = 2 +) + +var CMsgDOTAFantasyLeagueEditInfoResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyLeagueEditInfoResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAFantasyLeagueEditInfoResponse_EResult) Enum() *CMsgDOTAFantasyLeagueEditInfoResponse_EResult { + p := new(CMsgDOTAFantasyLeagueEditInfoResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeagueEditInfoResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeagueEditInfoResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeagueEditInfoResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeagueEditInfoResponse_EResult_value, data, "CMsgDOTAFantasyLeagueEditInfoResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeagueEditInfoResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeagueEditInfoResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{6, 0} +} + +type CMsgDOTAFantasyLeagueFindResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeagueFindResponse_SUCCESS CMsgDOTAFantasyLeagueFindResponse_EResult = 0 + CMsgDOTAFantasyLeagueFindResponse_ERROR_LEAGUE_NOT_FOUND CMsgDOTAFantasyLeagueFindResponse_EResult = 1 + CMsgDOTAFantasyLeagueFindResponse_ERROR_BAD_PASSWORD CMsgDOTAFantasyLeagueFindResponse_EResult = 2 + CMsgDOTAFantasyLeagueFindResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeagueFindResponse_EResult = 3 + CMsgDOTAFantasyLeagueFindResponse_ERROR_FULL CMsgDOTAFantasyLeagueFindResponse_EResult = 4 + CMsgDOTAFantasyLeagueFindResponse_ERROR_ALREADY_MEMBER CMsgDOTAFantasyLeagueFindResponse_EResult = 5 + CMsgDOTAFantasyLeagueFindResponse_ERROR_LEAGUE_LOCKED CMsgDOTAFantasyLeagueFindResponse_EResult = 6 +) + +var CMsgDOTAFantasyLeagueFindResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_LEAGUE_NOT_FOUND", + 2: "ERROR_BAD_PASSWORD", + 3: "ERROR_UNSPECIFIED", + 4: "ERROR_FULL", + 5: "ERROR_ALREADY_MEMBER", + 6: "ERROR_LEAGUE_LOCKED", +} +var CMsgDOTAFantasyLeagueFindResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_LEAGUE_NOT_FOUND": 1, + "ERROR_BAD_PASSWORD": 2, + "ERROR_UNSPECIFIED": 3, + "ERROR_FULL": 4, + "ERROR_ALREADY_MEMBER": 5, + "ERROR_LEAGUE_LOCKED": 6, +} + +func (x CMsgDOTAFantasyLeagueFindResponse_EResult) Enum() *CMsgDOTAFantasyLeagueFindResponse_EResult { + p := new(CMsgDOTAFantasyLeagueFindResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeagueFindResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeagueFindResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeagueFindResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeagueFindResponse_EResult_value, data, "CMsgDOTAFantasyLeagueFindResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeagueFindResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeagueFindResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{8, 0} +} + +type CMsgDOTAFantasyLeagueInfoResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeagueInfoResponse_SUCCESS CMsgDOTAFantasyLeagueInfoResponse_EResult = 0 + CMsgDOTAFantasyLeagueInfoResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeagueInfoResponse_EResult = 1 + CMsgDOTAFantasyLeagueInfoResponse_ERROR_BAD_LEAGUE_ID CMsgDOTAFantasyLeagueInfoResponse_EResult = 2 +) + +var CMsgDOTAFantasyLeagueInfoResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_BAD_LEAGUE_ID", +} +var CMsgDOTAFantasyLeagueInfoResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_BAD_LEAGUE_ID": 2, +} + +func (x CMsgDOTAFantasyLeagueInfoResponse_EResult) Enum() *CMsgDOTAFantasyLeagueInfoResponse_EResult { + p := new(CMsgDOTAFantasyLeagueInfoResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeagueInfoResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeagueInfoResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeagueInfoResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeagueInfoResponse_EResult_value, data, "CMsgDOTAFantasyLeagueInfoResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeagueInfoResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeagueInfoResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{10, 0} +} + +type CMsgDOTAFantasyLeagueMatchupsResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeagueMatchupsResponse_SUCCESS CMsgDOTAFantasyLeagueMatchupsResponse_EResult = 0 + CMsgDOTAFantasyLeagueMatchupsResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeagueMatchupsResponse_EResult = 1 + CMsgDOTAFantasyLeagueMatchupsResponse_ERROR_BAD_LEAGUE_ID CMsgDOTAFantasyLeagueMatchupsResponse_EResult = 2 + CMsgDOTAFantasyLeagueMatchupsResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyLeagueMatchupsResponse_EResult = 3 +) + +var CMsgDOTAFantasyLeagueMatchupsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_BAD_LEAGUE_ID", + 3: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyLeagueMatchupsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_BAD_LEAGUE_ID": 2, + "ERROR_NO_PERMISSION": 3, +} + +func (x CMsgDOTAFantasyLeagueMatchupsResponse_EResult) Enum() *CMsgDOTAFantasyLeagueMatchupsResponse_EResult { + p := new(CMsgDOTAFantasyLeagueMatchupsResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeagueMatchupsResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeagueMatchupsResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeagueMatchupsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeagueMatchupsResponse_EResult_value, data, "CMsgDOTAFantasyLeagueMatchupsResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeagueMatchupsResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeagueMatchupsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{12, 0} +} + +type CMsgDOTAEditFantasyTeamResponse_EResult int32 + +const ( + CMsgDOTAEditFantasyTeamResponse_SUCCESS CMsgDOTAEditFantasyTeamResponse_EResult = 0 + CMsgDOTAEditFantasyTeamResponse_ERROR_UNSPECIFIED CMsgDOTAEditFantasyTeamResponse_EResult = 1 + CMsgDOTAEditFantasyTeamResponse_ERROR_INVALID_TEAM_INFO CMsgDOTAEditFantasyTeamResponse_EResult = 2 + CMsgDOTAEditFantasyTeamResponse_ERROR_NAME_ALREADY_TAKEN CMsgDOTAEditFantasyTeamResponse_EResult = 3 + CMsgDOTAEditFantasyTeamResponse_ERROR_NO_PERMISSION CMsgDOTAEditFantasyTeamResponse_EResult = 4 +) + +var CMsgDOTAEditFantasyTeamResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_INVALID_TEAM_INFO", + 3: "ERROR_NAME_ALREADY_TAKEN", + 4: "ERROR_NO_PERMISSION", +} +var CMsgDOTAEditFantasyTeamResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_INVALID_TEAM_INFO": 2, + "ERROR_NAME_ALREADY_TAKEN": 3, + "ERROR_NO_PERMISSION": 4, +} + +func (x CMsgDOTAEditFantasyTeamResponse_EResult) Enum() *CMsgDOTAEditFantasyTeamResponse_EResult { + p := new(CMsgDOTAEditFantasyTeamResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAEditFantasyTeamResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAEditFantasyTeamResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAEditFantasyTeamResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAEditFantasyTeamResponse_EResult_value, data, "CMsgDOTAEditFantasyTeamResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAEditFantasyTeamResponse_EResult(value) + return nil +} +func (CMsgDOTAEditFantasyTeamResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{14, 0} +} + +type CMsgDOTAFantasyTeamScoreResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamScoreResponse_SUCCESS CMsgDOTAFantasyTeamScoreResponse_EResult = 0 + CMsgDOTAFantasyTeamScoreResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamScoreResponse_EResult = 1 + CMsgDOTAFantasyTeamScoreResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyTeamScoreResponse_EResult = 2 + CMsgDOTAFantasyTeamScoreResponse_ERROR_OWNER_NOT_IN_LEAGUE CMsgDOTAFantasyTeamScoreResponse_EResult = 3 +) + +var CMsgDOTAFantasyTeamScoreResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", + 3: "ERROR_OWNER_NOT_IN_LEAGUE", +} +var CMsgDOTAFantasyTeamScoreResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, + "ERROR_OWNER_NOT_IN_LEAGUE": 3, +} + +func (x CMsgDOTAFantasyTeamScoreResponse_EResult) Enum() *CMsgDOTAFantasyTeamScoreResponse_EResult { + p := new(CMsgDOTAFantasyTeamScoreResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamScoreResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamScoreResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamScoreResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamScoreResponse_EResult_value, data, "CMsgDOTAFantasyTeamScoreResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamScoreResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamScoreResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{20, 0} +} + +type CMsgDOTAFantasyTeamStandingsResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamStandingsResponse_SUCCESS CMsgDOTAFantasyTeamStandingsResponse_EResult = 0 + CMsgDOTAFantasyTeamStandingsResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamStandingsResponse_EResult = 1 + CMsgDOTAFantasyTeamStandingsResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyTeamStandingsResponse_EResult = 2 +) + +var CMsgDOTAFantasyTeamStandingsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyTeamStandingsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAFantasyTeamStandingsResponse_EResult) Enum() *CMsgDOTAFantasyTeamStandingsResponse_EResult { + p := new(CMsgDOTAFantasyTeamStandingsResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamStandingsResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamStandingsResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamStandingsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamStandingsResponse_EResult_value, data, "CMsgDOTAFantasyTeamStandingsResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamStandingsResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamStandingsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{22, 0} +} + +type CMsgDOTAFantasyPlayerScoreResponse_EResult int32 + +const ( + CMsgDOTAFantasyPlayerScoreResponse_SUCCESS CMsgDOTAFantasyPlayerScoreResponse_EResult = 0 + CMsgDOTAFantasyPlayerScoreResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyPlayerScoreResponse_EResult = 1 + CMsgDOTAFantasyPlayerScoreResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyPlayerScoreResponse_EResult = 2 +) + +var CMsgDOTAFantasyPlayerScoreResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyPlayerScoreResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAFantasyPlayerScoreResponse_EResult) Enum() *CMsgDOTAFantasyPlayerScoreResponse_EResult { + p := new(CMsgDOTAFantasyPlayerScoreResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyPlayerScoreResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyPlayerScoreResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyPlayerScoreResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyPlayerScoreResponse_EResult_value, data, "CMsgDOTAFantasyPlayerScoreResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyPlayerScoreResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyPlayerScoreResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{24, 0} +} + +type CMsgDOTAFantasyPlayerStandingsResponse_EResult int32 + +const ( + CMsgDOTAFantasyPlayerStandingsResponse_SUCCESS CMsgDOTAFantasyPlayerStandingsResponse_EResult = 0 + CMsgDOTAFantasyPlayerStandingsResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyPlayerStandingsResponse_EResult = 1 + CMsgDOTAFantasyPlayerStandingsResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyPlayerStandingsResponse_EResult = 2 +) + +var CMsgDOTAFantasyPlayerStandingsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyPlayerStandingsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAFantasyPlayerStandingsResponse_EResult) Enum() *CMsgDOTAFantasyPlayerStandingsResponse_EResult { + p := new(CMsgDOTAFantasyPlayerStandingsResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyPlayerStandingsResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyPlayerStandingsResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyPlayerStandingsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyPlayerStandingsResponse_EResult_value, data, "CMsgDOTAFantasyPlayerStandingsResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyPlayerStandingsResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyPlayerStandingsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{26, 0} +} + +type CMsgDOTAFantasyLeagueCreateResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeagueCreateResponse_SUCCESS CMsgDOTAFantasyLeagueCreateResponse_EResult = 0 + CMsgDOTAFantasyLeagueCreateResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyLeagueCreateResponse_EResult = 1 + CMsgDOTAFantasyLeagueCreateResponse_ERROR_BAD_SEASON_ID CMsgDOTAFantasyLeagueCreateResponse_EResult = 2 + CMsgDOTAFantasyLeagueCreateResponse_ERROR_BAD_LEAGUE_NAME CMsgDOTAFantasyLeagueCreateResponse_EResult = 3 + CMsgDOTAFantasyLeagueCreateResponse_ERROR_BAD_TEAM_NAME CMsgDOTAFantasyLeagueCreateResponse_EResult = 4 + CMsgDOTAFantasyLeagueCreateResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeagueCreateResponse_EResult = 5 + CMsgDOTAFantasyLeagueCreateResponse_ERROR_FAILED_LOGO_UPLOAD CMsgDOTAFantasyLeagueCreateResponse_EResult = 6 + CMsgDOTAFantasyLeagueCreateResponse_ERROR_NO_TICKET CMsgDOTAFantasyLeagueCreateResponse_EResult = 7 +) + +var CMsgDOTAFantasyLeagueCreateResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_NO_PERMISSION", + 2: "ERROR_BAD_SEASON_ID", + 3: "ERROR_BAD_LEAGUE_NAME", + 4: "ERROR_BAD_TEAM_NAME", + 5: "ERROR_UNSPECIFIED", + 6: "ERROR_FAILED_LOGO_UPLOAD", + 7: "ERROR_NO_TICKET", +} +var CMsgDOTAFantasyLeagueCreateResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_NO_PERMISSION": 1, + "ERROR_BAD_SEASON_ID": 2, + "ERROR_BAD_LEAGUE_NAME": 3, + "ERROR_BAD_TEAM_NAME": 4, + "ERROR_UNSPECIFIED": 5, + "ERROR_FAILED_LOGO_UPLOAD": 6, + "ERROR_NO_TICKET": 7, +} + +func (x CMsgDOTAFantasyLeagueCreateResponse_EResult) Enum() *CMsgDOTAFantasyLeagueCreateResponse_EResult { + p := new(CMsgDOTAFantasyLeagueCreateResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeagueCreateResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeagueCreateResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeagueCreateResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeagueCreateResponse_EResult_value, data, "CMsgDOTAFantasyLeagueCreateResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeagueCreateResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeagueCreateResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{30, 0} +} + +type CMsgDOTAFantasyTeamCreateResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamCreateResponse_SUCCESS CMsgDOTAFantasyTeamCreateResponse_EResult = 0 + CMsgDOTAFantasyTeamCreateResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyTeamCreateResponse_EResult = 1 + CMsgDOTAFantasyTeamCreateResponse_ERROR_FAILED_LOGO_UPLOAD CMsgDOTAFantasyTeamCreateResponse_EResult = 2 + CMsgDOTAFantasyTeamCreateResponse_ERROR_BAD_FANTASY_LEAGUE_ID CMsgDOTAFantasyTeamCreateResponse_EResult = 3 + CMsgDOTAFantasyTeamCreateResponse_ERROR_BAD_NAME CMsgDOTAFantasyTeamCreateResponse_EResult = 4 + CMsgDOTAFantasyTeamCreateResponse_ERROR_FULL CMsgDOTAFantasyTeamCreateResponse_EResult = 5 + CMsgDOTAFantasyTeamCreateResponse_ERROR_ALREADY_MEMBER CMsgDOTAFantasyTeamCreateResponse_EResult = 6 + CMsgDOTAFantasyTeamCreateResponse_ERROR_BAD_PASSWORD CMsgDOTAFantasyTeamCreateResponse_EResult = 7 + CMsgDOTAFantasyTeamCreateResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamCreateResponse_EResult = 8 + CMsgDOTAFantasyTeamCreateResponse_ERROR_NO_TICKET CMsgDOTAFantasyTeamCreateResponse_EResult = 9 + CMsgDOTAFantasyTeamCreateResponse_ERROR_LEAGUE_LOCKED CMsgDOTAFantasyTeamCreateResponse_EResult = 10 +) + +var CMsgDOTAFantasyTeamCreateResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_NO_PERMISSION", + 2: "ERROR_FAILED_LOGO_UPLOAD", + 3: "ERROR_BAD_FANTASY_LEAGUE_ID", + 4: "ERROR_BAD_NAME", + 5: "ERROR_FULL", + 6: "ERROR_ALREADY_MEMBER", + 7: "ERROR_BAD_PASSWORD", + 8: "ERROR_UNSPECIFIED", + 9: "ERROR_NO_TICKET", + 10: "ERROR_LEAGUE_LOCKED", +} +var CMsgDOTAFantasyTeamCreateResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_NO_PERMISSION": 1, + "ERROR_FAILED_LOGO_UPLOAD": 2, + "ERROR_BAD_FANTASY_LEAGUE_ID": 3, + "ERROR_BAD_NAME": 4, + "ERROR_FULL": 5, + "ERROR_ALREADY_MEMBER": 6, + "ERROR_BAD_PASSWORD": 7, + "ERROR_UNSPECIFIED": 8, + "ERROR_NO_TICKET": 9, + "ERROR_LEAGUE_LOCKED": 10, +} + +func (x CMsgDOTAFantasyTeamCreateResponse_EResult) Enum() *CMsgDOTAFantasyTeamCreateResponse_EResult { + p := new(CMsgDOTAFantasyTeamCreateResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamCreateResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamCreateResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamCreateResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamCreateResponse_EResult_value, data, "CMsgDOTAFantasyTeamCreateResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamCreateResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamCreateResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{32, 0} +} + +type CMsgDOTAFantasyLeagueEditInvitesResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeagueEditInvitesResponse_SUCCESS CMsgDOTAFantasyLeagueEditInvitesResponse_EResult = 0 + CMsgDOTAFantasyLeagueEditInvitesResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeagueEditInvitesResponse_EResult = 1 +) + +var CMsgDOTAFantasyLeagueEditInvitesResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", +} +var CMsgDOTAFantasyLeagueEditInvitesResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, +} + +func (x CMsgDOTAFantasyLeagueEditInvitesResponse_EResult) Enum() *CMsgDOTAFantasyLeagueEditInvitesResponse_EResult { + p := new(CMsgDOTAFantasyLeagueEditInvitesResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeagueEditInvitesResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeagueEditInvitesResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeagueEditInvitesResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeagueEditInvitesResponse_EResult_value, data, "CMsgDOTAFantasyLeagueEditInvitesResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeagueEditInvitesResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeagueEditInvitesResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{34, 0} +} + +type CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeagueDraftPlayerResponse_SUCCESS CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 0 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 1 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_INVALID_FANTASY_LEAGUE CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 2 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_FANTASY_LEAGUE_NOT_DRAFTING CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 3 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_OWNER_NOT_IN_LEAGUE CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 4 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_NOT_OWNERS_TURN CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 5 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_PLAYER_INVALID CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 6 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_PLAYER_UNAVAILABLE CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 7 + CMsgDOTAFantasyLeagueDraftPlayerResponse_ERROR_PLAYER_NO_VALID_SLOTS CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = 8 +) + +var CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_INVALID_FANTASY_LEAGUE", + 3: "ERROR_FANTASY_LEAGUE_NOT_DRAFTING", + 4: "ERROR_OWNER_NOT_IN_LEAGUE", + 5: "ERROR_NOT_OWNERS_TURN", + 6: "ERROR_PLAYER_INVALID", + 7: "ERROR_PLAYER_UNAVAILABLE", + 8: "ERROR_PLAYER_NO_VALID_SLOTS", +} +var CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_INVALID_FANTASY_LEAGUE": 2, + "ERROR_FANTASY_LEAGUE_NOT_DRAFTING": 3, + "ERROR_OWNER_NOT_IN_LEAGUE": 4, + "ERROR_NOT_OWNERS_TURN": 5, + "ERROR_PLAYER_INVALID": 6, + "ERROR_PLAYER_UNAVAILABLE": 7, + "ERROR_PLAYER_NO_VALID_SLOTS": 8, +} + +func (x CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult) Enum() *CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult { + p := new(CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult_value, data, "CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{38, 0} +} + +type CMsgDOTAFantasyTeamRosterSwapResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamRosterSwapResponse_SUCCESS CMsgDOTAFantasyTeamRosterSwapResponse_EResult = 0 + CMsgDOTAFantasyTeamRosterSwapResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamRosterSwapResponse_EResult = 1 + CMsgDOTAFantasyTeamRosterSwapResponse_ERROR_OWNER_NOT_IN_LEAGUE CMsgDOTAFantasyTeamRosterSwapResponse_EResult = 2 + CMsgDOTAFantasyTeamRosterSwapResponse_ERROR_SLOTS_INVALID CMsgDOTAFantasyTeamRosterSwapResponse_EResult = 3 + CMsgDOTAFantasyTeamRosterSwapResponse_ERROR_SLOT_LOCKED CMsgDOTAFantasyTeamRosterSwapResponse_EResult = 4 +) + +var CMsgDOTAFantasyTeamRosterSwapResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_OWNER_NOT_IN_LEAGUE", + 3: "ERROR_SLOTS_INVALID", + 4: "ERROR_SLOT_LOCKED", +} +var CMsgDOTAFantasyTeamRosterSwapResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_OWNER_NOT_IN_LEAGUE": 2, + "ERROR_SLOTS_INVALID": 3, + "ERROR_SLOT_LOCKED": 4, +} + +func (x CMsgDOTAFantasyTeamRosterSwapResponse_EResult) Enum() *CMsgDOTAFantasyTeamRosterSwapResponse_EResult { + p := new(CMsgDOTAFantasyTeamRosterSwapResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamRosterSwapResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamRosterSwapResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamRosterSwapResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamRosterSwapResponse_EResult_value, data, "CMsgDOTAFantasyTeamRosterSwapResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamRosterSwapResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamRosterSwapResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{40, 0} +} + +type CMsgDOTAFantasyTeamRosterAddDropResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamRosterAddDropResponse_SUCCESS CMsgDOTAFantasyTeamRosterAddDropResponse_EResult = 0 + CMsgDOTAFantasyTeamRosterAddDropResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamRosterAddDropResponse_EResult = 1 + CMsgDOTAFantasyTeamRosterAddDropResponse_ERROR_OWNER_NOT_IN_LEAGUE CMsgDOTAFantasyTeamRosterAddDropResponse_EResult = 2 + CMsgDOTAFantasyTeamRosterAddDropResponse_ERROR_PLAYER_NOT_AVAILABLE CMsgDOTAFantasyTeamRosterAddDropResponse_EResult = 3 + CMsgDOTAFantasyTeamRosterAddDropResponse_ERROR_PLAYER_NOT_ON_TEAM CMsgDOTAFantasyTeamRosterAddDropResponse_EResult = 4 + CMsgDOTAFantasyTeamRosterAddDropResponse_ERROR_TRADE_ALREADY_PENDING CMsgDOTAFantasyTeamRosterAddDropResponse_EResult = 5 +) + +var CMsgDOTAFantasyTeamRosterAddDropResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_OWNER_NOT_IN_LEAGUE", + 3: "ERROR_PLAYER_NOT_AVAILABLE", + 4: "ERROR_PLAYER_NOT_ON_TEAM", + 5: "ERROR_TRADE_ALREADY_PENDING", +} +var CMsgDOTAFantasyTeamRosterAddDropResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_OWNER_NOT_IN_LEAGUE": 2, + "ERROR_PLAYER_NOT_AVAILABLE": 3, + "ERROR_PLAYER_NOT_ON_TEAM": 4, + "ERROR_TRADE_ALREADY_PENDING": 5, +} + +func (x CMsgDOTAFantasyTeamRosterAddDropResponse_EResult) Enum() *CMsgDOTAFantasyTeamRosterAddDropResponse_EResult { + p := new(CMsgDOTAFantasyTeamRosterAddDropResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamRosterAddDropResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamRosterAddDropResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamRosterAddDropResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamRosterAddDropResponse_EResult_value, data, "CMsgDOTAFantasyTeamRosterAddDropResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamRosterAddDropResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamRosterAddDropResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{42, 0} +} + +type CMsgDOTAFantasyTeamTradesResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamTradesResponse_SUCCESS CMsgDOTAFantasyTeamTradesResponse_EResult = 0 + CMsgDOTAFantasyTeamTradesResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamTradesResponse_EResult = 1 + CMsgDOTAFantasyTeamTradesResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyTeamTradesResponse_EResult = 2 +) + +var CMsgDOTAFantasyTeamTradesResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyTeamTradesResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAFantasyTeamTradesResponse_EResult) Enum() *CMsgDOTAFantasyTeamTradesResponse_EResult { + p := new(CMsgDOTAFantasyTeamTradesResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamTradesResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamTradesResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamTradesResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamTradesResponse_EResult_value, data, "CMsgDOTAFantasyTeamTradesResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamTradesResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamTradesResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{44, 0} +} + +type CMsgDOTAFantasyTeamTradeCancelResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamTradeCancelResponse_SUCCESS CMsgDOTAFantasyTeamTradeCancelResponse_EResult = 0 + CMsgDOTAFantasyTeamTradeCancelResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamTradeCancelResponse_EResult = 1 + CMsgDOTAFantasyTeamTradeCancelResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyTeamTradeCancelResponse_EResult = 2 + CMsgDOTAFantasyTeamTradeCancelResponse_ERROR_NO_TRADE CMsgDOTAFantasyTeamTradeCancelResponse_EResult = 3 +) + +var CMsgDOTAFantasyTeamTradeCancelResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", + 3: "ERROR_NO_TRADE", +} +var CMsgDOTAFantasyTeamTradeCancelResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, + "ERROR_NO_TRADE": 3, +} + +func (x CMsgDOTAFantasyTeamTradeCancelResponse_EResult) Enum() *CMsgDOTAFantasyTeamTradeCancelResponse_EResult { + p := new(CMsgDOTAFantasyTeamTradeCancelResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamTradeCancelResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamTradeCancelResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamTradeCancelResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamTradeCancelResponse_EResult_value, data, "CMsgDOTAFantasyTeamTradeCancelResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamTradeCancelResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamTradeCancelResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{46, 0} +} + +type CMsgDOTAFantasyTeamRosterResponse_EResult int32 + +const ( + CMsgDOTAFantasyTeamRosterResponse_SUCCESS CMsgDOTAFantasyTeamRosterResponse_EResult = 0 + CMsgDOTAFantasyTeamRosterResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyTeamRosterResponse_EResult = 1 + CMsgDOTAFantasyTeamRosterResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyTeamRosterResponse_EResult = 2 + CMsgDOTAFantasyTeamRosterResponse_ERROR_OWNER_NOT_IN_LEAGUE CMsgDOTAFantasyTeamRosterResponse_EResult = 3 +) + +var CMsgDOTAFantasyTeamRosterResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", + 3: "ERROR_OWNER_NOT_IN_LEAGUE", +} +var CMsgDOTAFantasyTeamRosterResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, + "ERROR_OWNER_NOT_IN_LEAGUE": 3, +} + +func (x CMsgDOTAFantasyTeamRosterResponse_EResult) Enum() *CMsgDOTAFantasyTeamRosterResponse_EResult { + p := new(CMsgDOTAFantasyTeamRosterResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyTeamRosterResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyTeamRosterResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyTeamRosterResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyTeamRosterResponse_EResult_value, data, "CMsgDOTAFantasyTeamRosterResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyTeamRosterResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyTeamRosterResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{48, 0} +} + +type CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult int32 + +const ( + CMsgDOTAFantasyPlayerHisoricalStatsResponse_SUCCESS CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult = 0 + CMsgDOTAFantasyPlayerHisoricalStatsResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult = 1 + CMsgDOTAFantasyPlayerHisoricalStatsResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult = 2 +) + +var CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult) Enum() *CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult { + p := new(CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult_value, data, "CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{50, 0} +} + +type CMsgDOTAFantasyMessagesResponse_EResult int32 + +const ( + CMsgDOTAFantasyMessagesResponse_SUCCESS CMsgDOTAFantasyMessagesResponse_EResult = 0 + CMsgDOTAFantasyMessagesResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyMessagesResponse_EResult = 1 + CMsgDOTAFantasyMessagesResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyMessagesResponse_EResult = 2 +) + +var CMsgDOTAFantasyMessagesResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", +} +var CMsgDOTAFantasyMessagesResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, +} + +func (x CMsgDOTAFantasyMessagesResponse_EResult) Enum() *CMsgDOTAFantasyMessagesResponse_EResult { + p := new(CMsgDOTAFantasyMessagesResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyMessagesResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyMessagesResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyMessagesResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyMessagesResponse_EResult_value, data, "CMsgDOTAFantasyMessagesResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyMessagesResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyMessagesResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{53, 0} +} + +type CMsgDOTAFantasyRemoveOwnerResponse_EResult int32 + +const ( + CMsgDOTAFantasyRemoveOwnerResponse_SUCCESS CMsgDOTAFantasyRemoveOwnerResponse_EResult = 0 + CMsgDOTAFantasyRemoveOwnerResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyRemoveOwnerResponse_EResult = 1 + CMsgDOTAFantasyRemoveOwnerResponse_ERROR_NO_PERMISSION CMsgDOTAFantasyRemoveOwnerResponse_EResult = 2 + CMsgDOTAFantasyRemoveOwnerResponse_ERROR_LEAGUE_LOCKED CMsgDOTAFantasyRemoveOwnerResponse_EResult = 3 + CMsgDOTAFantasyRemoveOwnerResponse_ERROR_NOT_A_MEMBER CMsgDOTAFantasyRemoveOwnerResponse_EResult = 4 +) + +var CMsgDOTAFantasyRemoveOwnerResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NO_PERMISSION", + 3: "ERROR_LEAGUE_LOCKED", + 4: "ERROR_NOT_A_MEMBER", +} +var CMsgDOTAFantasyRemoveOwnerResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NO_PERMISSION": 2, + "ERROR_LEAGUE_LOCKED": 3, + "ERROR_NOT_A_MEMBER": 4, +} + +func (x CMsgDOTAFantasyRemoveOwnerResponse_EResult) Enum() *CMsgDOTAFantasyRemoveOwnerResponse_EResult { + p := new(CMsgDOTAFantasyRemoveOwnerResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyRemoveOwnerResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyRemoveOwnerResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyRemoveOwnerResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyRemoveOwnerResponse_EResult_value, data, "CMsgDOTAFantasyRemoveOwnerResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyRemoveOwnerResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyRemoveOwnerResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{55, 0} +} + +type CMsgDOTAFantasyScheduledMatchesResponse_EResult int32 + +const ( + CMsgDOTAFantasyScheduledMatchesResponse_SUCCESS CMsgDOTAFantasyScheduledMatchesResponse_EResult = 0 + CMsgDOTAFantasyScheduledMatchesResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyScheduledMatchesResponse_EResult = 1 +) + +var CMsgDOTAFantasyScheduledMatchesResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", +} +var CMsgDOTAFantasyScheduledMatchesResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, +} + +func (x CMsgDOTAFantasyScheduledMatchesResponse_EResult) Enum() *CMsgDOTAFantasyScheduledMatchesResponse_EResult { + p := new(CMsgDOTAFantasyScheduledMatchesResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyScheduledMatchesResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyScheduledMatchesResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyScheduledMatchesResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyScheduledMatchesResponse_EResult_value, data, "CMsgDOTAFantasyScheduledMatchesResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyScheduledMatchesResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyScheduledMatchesResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{57, 0} +} + +type CMsgDOTAFantasyLeaveLeagueResponse_EResult int32 + +const ( + CMsgDOTAFantasyLeaveLeagueResponse_SUCCESS CMsgDOTAFantasyLeaveLeagueResponse_EResult = 0 + CMsgDOTAFantasyLeaveLeagueResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyLeaveLeagueResponse_EResult = 1 + CMsgDOTAFantasyLeaveLeagueResponse_ERROR_NOT_MEMBER CMsgDOTAFantasyLeaveLeagueResponse_EResult = 2 + CMsgDOTAFantasyLeaveLeagueResponse_ERROR_LEAGUE_NOT_FOUND CMsgDOTAFantasyLeaveLeagueResponse_EResult = 3 + CMsgDOTAFantasyLeaveLeagueResponse_ERROR_DRAFT_ACTIVE CMsgDOTAFantasyLeaveLeagueResponse_EResult = 4 +) + +var CMsgDOTAFantasyLeaveLeagueResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NOT_MEMBER", + 3: "ERROR_LEAGUE_NOT_FOUND", + 4: "ERROR_DRAFT_ACTIVE", +} +var CMsgDOTAFantasyLeaveLeagueResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NOT_MEMBER": 2, + "ERROR_LEAGUE_NOT_FOUND": 3, + "ERROR_DRAFT_ACTIVE": 4, +} + +func (x CMsgDOTAFantasyLeaveLeagueResponse_EResult) Enum() *CMsgDOTAFantasyLeaveLeagueResponse_EResult { + p := new(CMsgDOTAFantasyLeaveLeagueResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyLeaveLeagueResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyLeaveLeagueResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyLeaveLeagueResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyLeaveLeagueResponse_EResult_value, data, "CMsgDOTAFantasyLeaveLeagueResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyLeaveLeagueResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyLeaveLeagueResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{59, 0} +} + +type CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult int32 + +const ( + CMsgDOTAFantasyPlayerScoreDetailsResponse_SUCCESS CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult = 0 + CMsgDOTAFantasyPlayerScoreDetailsResponse_ERROR_UNSPECIFIED CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult = 1 + CMsgDOTAFantasyPlayerScoreDetailsResponse_ERROR_NOT_MEMBER CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult = 2 +) + +var CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult_name = map[int32]string{ + 0: "SUCCESS", + 1: "ERROR_UNSPECIFIED", + 2: "ERROR_NOT_MEMBER", +} +var CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult_value = map[string]int32{ + "SUCCESS": 0, + "ERROR_UNSPECIFIED": 1, + "ERROR_NOT_MEMBER": 2, +} + +func (x CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult) Enum() *CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult { + p := new(CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult) + *p = x + return p +} +func (x CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult) String() string { + return proto.EnumName(CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult_name, int32(x)) +} +func (x *CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult_value, data, "CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult") + if err != nil { + return err + } + *x = CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult(value) + return nil +} +func (CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{61, 0} +} + +type CMsgGCPlayerInfo struct { + PlayerInfos []*CMsgGCPlayerInfo_PlayerInfo `protobuf:"bytes,1,rep,name=player_infos" json:"player_infos,omitempty"` + Leaderboards []*CMsgGCPlayerInfo_RegionLeaderboard `protobuf:"bytes,2,rep,name=leaderboards" json:"leaderboards,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPlayerInfo) Reset() { *m = CMsgGCPlayerInfo{} } +func (m *CMsgGCPlayerInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPlayerInfo) ProtoMessage() {} +func (*CMsgGCPlayerInfo) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{0} } + +func (m *CMsgGCPlayerInfo) GetPlayerInfos() []*CMsgGCPlayerInfo_PlayerInfo { + if m != nil { + return m.PlayerInfos + } + return nil +} + +func (m *CMsgGCPlayerInfo) GetLeaderboards() []*CMsgGCPlayerInfo_RegionLeaderboard { + if m != nil { + return m.Leaderboards + } + return nil +} + +type CMsgGCPlayerInfo_PlayerInfo struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + CountryCode *string `protobuf:"bytes,3,opt,name=country_code" json:"country_code,omitempty"` + FantasyRole *uint32 `protobuf:"varint,4,opt,name=fantasy_role" json:"fantasy_role,omitempty"` + TeamId *uint32 `protobuf:"varint,5,opt,name=team_id" json:"team_id,omitempty"` + TeamName *string `protobuf:"bytes,6,opt,name=team_name" json:"team_name,omitempty"` + TeamTag *string `protobuf:"bytes,7,opt,name=team_tag" json:"team_tag,omitempty"` + Sponsor *string `protobuf:"bytes,8,opt,name=sponsor" json:"sponsor,omitempty"` + IsLocked *bool `protobuf:"varint,9,opt,name=is_locked" json:"is_locked,omitempty"` + IsPro *bool `protobuf:"varint,10,opt,name=is_pro" json:"is_pro,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) Reset() { *m = CMsgGCPlayerInfo_PlayerInfo{} } +func (m *CMsgGCPlayerInfo_PlayerInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPlayerInfo_PlayerInfo) ProtoMessage() {} +func (*CMsgGCPlayerInfo_PlayerInfo) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{0, 0} } + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetFantasyRole() uint32 { + if m != nil && m.FantasyRole != nil { + return *m.FantasyRole + } + return 0 +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetTeamTag() string { + if m != nil && m.TeamTag != nil { + return *m.TeamTag + } + return "" +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetSponsor() string { + if m != nil && m.Sponsor != nil { + return *m.Sponsor + } + return "" +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetIsLocked() bool { + if m != nil && m.IsLocked != nil { + return *m.IsLocked + } + return false +} + +func (m *CMsgGCPlayerInfo_PlayerInfo) GetIsPro() bool { + if m != nil && m.IsPro != nil { + return *m.IsPro + } + return false +} + +type CMsgGCPlayerInfo_RegionLeaderboard struct { + Division *uint32 `protobuf:"varint,1,opt,name=division" json:"division,omitempty"` + AccountIds []uint32 `protobuf:"varint,2,rep,name=account_ids" json:"account_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPlayerInfo_RegionLeaderboard) Reset() { *m = CMsgGCPlayerInfo_RegionLeaderboard{} } +func (m *CMsgGCPlayerInfo_RegionLeaderboard) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPlayerInfo_RegionLeaderboard) ProtoMessage() {} +func (*CMsgGCPlayerInfo_RegionLeaderboard) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{0, 1} +} + +func (m *CMsgGCPlayerInfo_RegionLeaderboard) GetDivision() uint32 { + if m != nil && m.Division != nil { + return *m.Division + } + return 0 +} + +func (m *CMsgGCPlayerInfo_RegionLeaderboard) GetAccountIds() []uint32 { + if m != nil { + return m.AccountIds + } + return nil +} + +type CMsgDOTACreateFantasyLeagueRequest struct { + LeagueName *string `protobuf:"bytes,1,opt,name=league_name" json:"league_name,omitempty"` + LeagueLogo *uint64 `protobuf:"varint,2,opt,name=league_logo" json:"league_logo,omitempty"` + SelectionMode *Fantasy_Selection_Mode `protobuf:"varint,3,opt,name=selection_mode,enum=Fantasy_Selection_Mode,def=0" json:"selection_mode,omitempty"` + TeamCount *uint32 `protobuf:"varint,4,opt,name=team_count" json:"team_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACreateFantasyLeagueRequest) Reset() { *m = CMsgDOTACreateFantasyLeagueRequest{} } +func (m *CMsgDOTACreateFantasyLeagueRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACreateFantasyLeagueRequest) ProtoMessage() {} +func (*CMsgDOTACreateFantasyLeagueRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{1} +} + +const Default_CMsgDOTACreateFantasyLeagueRequest_SelectionMode Fantasy_Selection_Mode = Fantasy_Selection_Mode_FANTASY_SELECTION_INVALID + +func (m *CMsgDOTACreateFantasyLeagueRequest) GetLeagueName() string { + if m != nil && m.LeagueName != nil { + return *m.LeagueName + } + return "" +} + +func (m *CMsgDOTACreateFantasyLeagueRequest) GetLeagueLogo() uint64 { + if m != nil && m.LeagueLogo != nil { + return *m.LeagueLogo + } + return 0 +} + +func (m *CMsgDOTACreateFantasyLeagueRequest) GetSelectionMode() Fantasy_Selection_Mode { + if m != nil && m.SelectionMode != nil { + return *m.SelectionMode + } + return Default_CMsgDOTACreateFantasyLeagueRequest_SelectionMode +} + +func (m *CMsgDOTACreateFantasyLeagueRequest) GetTeamCount() uint32 { + if m != nil && m.TeamCount != nil { + return *m.TeamCount + } + return 0 +} + +type CMsgDOTACreateFantasyLeagueResponse struct { + Result *CMsgDOTACreateFantasyLeagueResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTACreateFantasyLeagueResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACreateFantasyLeagueResponse) Reset() { *m = CMsgDOTACreateFantasyLeagueResponse{} } +func (m *CMsgDOTACreateFantasyLeagueResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACreateFantasyLeagueResponse) ProtoMessage() {} +func (*CMsgDOTACreateFantasyLeagueResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{2} +} + +const Default_CMsgDOTACreateFantasyLeagueResponse_Result CMsgDOTACreateFantasyLeagueResponse_EResult = CMsgDOTACreateFantasyLeagueResponse_SUCCESS + +func (m *CMsgDOTACreateFantasyLeagueResponse) GetResult() CMsgDOTACreateFantasyLeagueResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTACreateFantasyLeagueResponse_Result +} + +type CMsgFantasyLeagueScoring struct { + Level *float32 `protobuf:"fixed32,1,opt,name=level" json:"level,omitempty"` + Kills *float32 `protobuf:"fixed32,2,opt,name=kills" json:"kills,omitempty"` + Deaths *float32 `protobuf:"fixed32,3,opt,name=deaths" json:"deaths,omitempty"` + Assists *float32 `protobuf:"fixed32,4,opt,name=assists" json:"assists,omitempty"` + LastHits *float32 `protobuf:"fixed32,5,opt,name=last_hits" json:"last_hits,omitempty"` + Denies *float32 `protobuf:"fixed32,6,opt,name=denies" json:"denies,omitempty"` + Gpm *float32 `protobuf:"fixed32,7,opt,name=gpm" json:"gpm,omitempty"` + Xppm *float32 `protobuf:"fixed32,8,opt,name=xppm" json:"xppm,omitempty"` + Stuns *float32 `protobuf:"fixed32,9,opt,name=stuns" json:"stuns,omitempty"` + Healing *float32 `protobuf:"fixed32,10,opt,name=healing" json:"healing,omitempty"` + TowerKills *float32 `protobuf:"fixed32,11,opt,name=tower_kills" json:"tower_kills,omitempty"` + RoshanKills *float32 `protobuf:"fixed32,12,opt,name=roshan_kills" json:"roshan_kills,omitempty"` + MultiplierPremium *float32 `protobuf:"fixed32,13,opt,name=multiplier_premium" json:"multiplier_premium,omitempty"` + MultiplierProfessional *float32 `protobuf:"fixed32,14,opt,name=multiplier_professional" json:"multiplier_professional,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFantasyLeagueScoring) Reset() { *m = CMsgFantasyLeagueScoring{} } +func (m *CMsgFantasyLeagueScoring) String() string { return proto.CompactTextString(m) } +func (*CMsgFantasyLeagueScoring) ProtoMessage() {} +func (*CMsgFantasyLeagueScoring) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{3} } + +func (m *CMsgFantasyLeagueScoring) GetLevel() float32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetKills() float32 { + if m != nil && m.Kills != nil { + return *m.Kills + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetDeaths() float32 { + if m != nil && m.Deaths != nil { + return *m.Deaths + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetAssists() float32 { + if m != nil && m.Assists != nil { + return *m.Assists + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetLastHits() float32 { + if m != nil && m.LastHits != nil { + return *m.LastHits + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetDenies() float32 { + if m != nil && m.Denies != nil { + return *m.Denies + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetGpm() float32 { + if m != nil && m.Gpm != nil { + return *m.Gpm + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetXppm() float32 { + if m != nil && m.Xppm != nil { + return *m.Xppm + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetStuns() float32 { + if m != nil && m.Stuns != nil { + return *m.Stuns + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetHealing() float32 { + if m != nil && m.Healing != nil { + return *m.Healing + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetTowerKills() float32 { + if m != nil && m.TowerKills != nil { + return *m.TowerKills + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetRoshanKills() float32 { + if m != nil && m.RoshanKills != nil { + return *m.RoshanKills + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetMultiplierPremium() float32 { + if m != nil && m.MultiplierPremium != nil { + return *m.MultiplierPremium + } + return 0 +} + +func (m *CMsgFantasyLeagueScoring) GetMultiplierProfessional() float32 { + if m != nil && m.MultiplierProfessional != nil { + return *m.MultiplierProfessional + } + return 0 +} + +type CMsgDOTAFantasyLeagueInfo struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + CommissionerAccountId *uint32 `protobuf:"varint,2,opt,name=commissioner_account_id" json:"commissioner_account_id,omitempty"` + FantasyLeagueName *string `protobuf:"bytes,3,opt,name=fantasy_league_name" json:"fantasy_league_name,omitempty"` + SelectionMode *Fantasy_Selection_Mode `protobuf:"varint,4,opt,name=selection_mode,enum=Fantasy_Selection_Mode,def=0" json:"selection_mode,omitempty"` + TeamCount *uint32 `protobuf:"varint,5,opt,name=team_count" json:"team_count,omitempty"` + Logo *uint64 `protobuf:"varint,6,opt,name=logo" json:"logo,omitempty"` + Scoring *CMsgFantasyLeagueScoring `protobuf:"bytes,7,opt,name=scoring" json:"scoring,omitempty"` + DraftTime *uint32 `protobuf:"varint,12,opt,name=draft_time" json:"draft_time,omitempty"` + DraftPickTime *uint32 `protobuf:"varint,13,opt,name=draft_pick_time" json:"draft_pick_time,omitempty"` + SeasonStart *uint32 `protobuf:"varint,15,opt,name=season_start" json:"season_start,omitempty"` + SeasonLength *uint32 `protobuf:"varint,16,opt,name=season_length" json:"season_length,omitempty"` + VetoVotes *uint32 `protobuf:"varint,17,opt,name=veto_votes" json:"veto_votes,omitempty"` + Acquisitions *uint32 `protobuf:"varint,18,opt,name=acquisitions" json:"acquisitions,omitempty"` + Slot_1 *uint32 `protobuf:"varint,19,opt,name=slot_1" json:"slot_1,omitempty"` + Slot_2 *uint32 `protobuf:"varint,20,opt,name=slot_2" json:"slot_2,omitempty"` + Slot_3 *uint32 `protobuf:"varint,21,opt,name=slot_3" json:"slot_3,omitempty"` + Slot_4 *uint32 `protobuf:"varint,22,opt,name=slot_4" json:"slot_4,omitempty"` + Slot_5 *uint32 `protobuf:"varint,23,opt,name=slot_5" json:"slot_5,omitempty"` + BenchSlots *uint32 `protobuf:"varint,24,opt,name=bench_slots" json:"bench_slots,omitempty"` + OwnerInfo []*CMsgDOTAFantasyLeagueInfo_OwnerInfo `protobuf:"bytes,25,rep,name=owner_info" json:"owner_info,omitempty"` + Players []uint32 `protobuf:"varint,26,rep,name=players" json:"players,omitempty"` + TimeZone *uint32 `protobuf:"varint,27,opt,name=time_zone" json:"time_zone,omitempty"` + Season *uint32 `protobuf:"varint,28,opt,name=season" json:"season,omitempty"` + Password *string `protobuf:"bytes,29,opt,name=password" json:"password,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueInfo) Reset() { *m = CMsgDOTAFantasyLeagueInfo{} } +func (m *CMsgDOTAFantasyLeagueInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueInfo) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueInfo) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{4} } + +const Default_CMsgDOTAFantasyLeagueInfo_SelectionMode Fantasy_Selection_Mode = Fantasy_Selection_Mode_FANTASY_SELECTION_INVALID + +func (m *CMsgDOTAFantasyLeagueInfo) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetCommissionerAccountId() uint32 { + if m != nil && m.CommissionerAccountId != nil { + return *m.CommissionerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetFantasyLeagueName() string { + if m != nil && m.FantasyLeagueName != nil { + return *m.FantasyLeagueName + } + return "" +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSelectionMode() Fantasy_Selection_Mode { + if m != nil && m.SelectionMode != nil { + return *m.SelectionMode + } + return Default_CMsgDOTAFantasyLeagueInfo_SelectionMode +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetTeamCount() uint32 { + if m != nil && m.TeamCount != nil { + return *m.TeamCount + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetScoring() *CMsgFantasyLeagueScoring { + if m != nil { + return m.Scoring + } + return nil +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetDraftTime() uint32 { + if m != nil && m.DraftTime != nil { + return *m.DraftTime + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetDraftPickTime() uint32 { + if m != nil && m.DraftPickTime != nil { + return *m.DraftPickTime + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSeasonStart() uint32 { + if m != nil && m.SeasonStart != nil { + return *m.SeasonStart + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSeasonLength() uint32 { + if m != nil && m.SeasonLength != nil { + return *m.SeasonLength + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetVetoVotes() uint32 { + if m != nil && m.VetoVotes != nil { + return *m.VetoVotes + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetAcquisitions() uint32 { + if m != nil && m.Acquisitions != nil { + return *m.Acquisitions + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSlot_1() uint32 { + if m != nil && m.Slot_1 != nil { + return *m.Slot_1 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSlot_2() uint32 { + if m != nil && m.Slot_2 != nil { + return *m.Slot_2 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSlot_3() uint32 { + if m != nil && m.Slot_3 != nil { + return *m.Slot_3 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSlot_4() uint32 { + if m != nil && m.Slot_4 != nil { + return *m.Slot_4 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSlot_5() uint32 { + if m != nil && m.Slot_5 != nil { + return *m.Slot_5 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetBenchSlots() uint32 { + if m != nil && m.BenchSlots != nil { + return *m.BenchSlots + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetOwnerInfo() []*CMsgDOTAFantasyLeagueInfo_OwnerInfo { + if m != nil { + return m.OwnerInfo + } + return nil +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetPlayers() []uint32 { + if m != nil { + return m.Players + } + return nil +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetTimeZone() uint32 { + if m != nil && m.TimeZone != nil { + return *m.TimeZone + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetSeason() uint32 { + if m != nil && m.Season != nil { + return *m.Season + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +type CMsgDOTAFantasyLeagueInfo_OwnerInfo struct { + OwnerAccountId *uint32 `protobuf:"varint,1,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + LeftLeague *bool `protobuf:"varint,2,opt,name=left_league" json:"left_league,omitempty"` + PlayerAccountId []uint32 `protobuf:"varint,3,rep,name=player_account_id" json:"player_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueInfo_OwnerInfo) Reset() { *m = CMsgDOTAFantasyLeagueInfo_OwnerInfo{} } +func (m *CMsgDOTAFantasyLeagueInfo_OwnerInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueInfo_OwnerInfo) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueInfo_OwnerInfo) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{4, 0} +} + +func (m *CMsgDOTAFantasyLeagueInfo_OwnerInfo) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueInfo_OwnerInfo) GetLeftLeague() bool { + if m != nil && m.LeftLeague != nil { + return *m.LeftLeague + } + return false +} + +func (m *CMsgDOTAFantasyLeagueInfo_OwnerInfo) GetPlayerAccountId() []uint32 { + if m != nil { + return m.PlayerAccountId + } + return nil +} + +type CMsgDOTAFantasyLeagueEditInfoRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + EditInfo *CMsgDOTAFantasyLeagueInfo `protobuf:"bytes,2,opt,name=edit_info" json:"edit_info,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueEditInfoRequest) Reset() { *m = CMsgDOTAFantasyLeagueEditInfoRequest{} } +func (m *CMsgDOTAFantasyLeagueEditInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueEditInfoRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueEditInfoRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{5} +} + +func (m *CMsgDOTAFantasyLeagueEditInfoRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueEditInfoRequest) GetEditInfo() *CMsgDOTAFantasyLeagueInfo { + if m != nil { + return m.EditInfo + } + return nil +} + +type CMsgDOTAFantasyLeagueEditInfoResponse struct { + Result *CMsgDOTAFantasyLeagueEditInfoResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeagueEditInfoResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueEditInfoResponse) Reset() { *m = CMsgDOTAFantasyLeagueEditInfoResponse{} } +func (m *CMsgDOTAFantasyLeagueEditInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueEditInfoResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueEditInfoResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{6} +} + +const Default_CMsgDOTAFantasyLeagueEditInfoResponse_Result CMsgDOTAFantasyLeagueEditInfoResponse_EResult = CMsgDOTAFantasyLeagueEditInfoResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeagueEditInfoResponse) GetResult() CMsgDOTAFantasyLeagueEditInfoResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeagueEditInfoResponse_Result +} + +type CMsgDOTAFantasyLeagueFindRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Password *string `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueFindRequest) Reset() { *m = CMsgDOTAFantasyLeagueFindRequest{} } +func (m *CMsgDOTAFantasyLeagueFindRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueFindRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueFindRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{7} +} + +func (m *CMsgDOTAFantasyLeagueFindRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueFindRequest) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +type CMsgDOTAFantasyLeagueFindResponse struct { + Result *CMsgDOTAFantasyLeagueFindResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeagueFindResponse_EResult,def=0" json:"result,omitempty"` + FantasyLeagueName *string `protobuf:"bytes,2,opt,name=fantasy_league_name" json:"fantasy_league_name,omitempty"` + CommissionerName *string `protobuf:"bytes,3,opt,name=commissioner_name" json:"commissioner_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueFindResponse) Reset() { *m = CMsgDOTAFantasyLeagueFindResponse{} } +func (m *CMsgDOTAFantasyLeagueFindResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueFindResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueFindResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{8} +} + +const Default_CMsgDOTAFantasyLeagueFindResponse_Result CMsgDOTAFantasyLeagueFindResponse_EResult = CMsgDOTAFantasyLeagueFindResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeagueFindResponse) GetResult() CMsgDOTAFantasyLeagueFindResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeagueFindResponse_Result +} + +func (m *CMsgDOTAFantasyLeagueFindResponse) GetFantasyLeagueName() string { + if m != nil && m.FantasyLeagueName != nil { + return *m.FantasyLeagueName + } + return "" +} + +func (m *CMsgDOTAFantasyLeagueFindResponse) GetCommissionerName() string { + if m != nil && m.CommissionerName != nil { + return *m.CommissionerName + } + return "" +} + +type CMsgDOTAFantasyLeagueInfoRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueInfoRequest) Reset() { *m = CMsgDOTAFantasyLeagueInfoRequest{} } +func (m *CMsgDOTAFantasyLeagueInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueInfoRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueInfoRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{9} +} + +func (m *CMsgDOTAFantasyLeagueInfoRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyLeagueInfoResponse struct { + Result *CMsgDOTAFantasyLeagueInfoResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeagueInfoResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueInfoResponse) Reset() { *m = CMsgDOTAFantasyLeagueInfoResponse{} } +func (m *CMsgDOTAFantasyLeagueInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueInfoResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueInfoResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{10} +} + +const Default_CMsgDOTAFantasyLeagueInfoResponse_Result CMsgDOTAFantasyLeagueInfoResponse_EResult = CMsgDOTAFantasyLeagueInfoResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeagueInfoResponse) GetResult() CMsgDOTAFantasyLeagueInfoResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeagueInfoResponse_Result +} + +type CMsgDOTAFantasyLeagueMatchupsRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueMatchupsRequest) Reset() { *m = CMsgDOTAFantasyLeagueMatchupsRequest{} } +func (m *CMsgDOTAFantasyLeagueMatchupsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueMatchupsRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueMatchupsRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{11} +} + +func (m *CMsgDOTAFantasyLeagueMatchupsRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyLeagueMatchupsResponse struct { + Result *CMsgDOTAFantasyLeagueMatchupsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeagueMatchupsResponse_EResult,def=0" json:"result,omitempty"` + FantasyLeagueId *uint32 `protobuf:"varint,2,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + WeeklyMatchups []*CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups `protobuf:"bytes,3,rep,name=weekly_matchups" json:"weekly_matchups,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse) Reset() { *m = CMsgDOTAFantasyLeagueMatchupsResponse{} } +func (m *CMsgDOTAFantasyLeagueMatchupsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueMatchupsResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueMatchupsResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{12} +} + +const Default_CMsgDOTAFantasyLeagueMatchupsResponse_Result CMsgDOTAFantasyLeagueMatchupsResponse_EResult = CMsgDOTAFantasyLeagueMatchupsResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse) GetResult() CMsgDOTAFantasyLeagueMatchupsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeagueMatchupsResponse_Result +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse) GetWeeklyMatchups() []*CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups { + if m != nil { + return m.WeeklyMatchups + } + return nil +} + +type CMsgDOTAFantasyLeagueMatchupsResponse_Matchup struct { + OwnerAccountId_1 *uint32 `protobuf:"varint,1,opt,name=owner_account_id_1" json:"owner_account_id_1,omitempty"` + OwnerAccountId_2 *uint32 `protobuf:"varint,2,opt,name=owner_account_id_2" json:"owner_account_id_2,omitempty"` + Score_1 *float32 `protobuf:"fixed32,3,opt,name=score_1" json:"score_1,omitempty"` + Score_2 *float32 `protobuf:"fixed32,4,opt,name=score_2" json:"score_2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) Reset() { + *m = CMsgDOTAFantasyLeagueMatchupsResponse_Matchup{} +} +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{12, 0} +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) GetOwnerAccountId_1() uint32 { + if m != nil && m.OwnerAccountId_1 != nil { + return *m.OwnerAccountId_1 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) GetOwnerAccountId_2() uint32 { + if m != nil && m.OwnerAccountId_2 != nil { + return *m.OwnerAccountId_2 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) GetScore_1() float32 { + if m != nil && m.Score_1 != nil { + return *m.Score_1 + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_Matchup) GetScore_2() float32 { + if m != nil && m.Score_2 != nil { + return *m.Score_2 + } + return 0 +} + +type CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups struct { + Matchup []*CMsgDOTAFantasyLeagueMatchupsResponse_Matchup `protobuf:"bytes,1,rep,name=matchup" json:"matchup,omitempty"` + StartTime *uint32 `protobuf:"varint,2,opt,name=start_time" json:"start_time,omitempty"` + EndTime *uint32 `protobuf:"varint,3,opt,name=end_time" json:"end_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups) Reset() { + *m = CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups{} +} +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{12, 1} +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups) GetMatchup() []*CMsgDOTAFantasyLeagueMatchupsResponse_Matchup { + if m != nil { + return m.Matchup + } + return nil +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups) GetEndTime() uint32 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +type CMsgDOTAEditFantasyTeamRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + TeamIndex *uint32 `protobuf:"varint,2,opt,name=team_index" json:"team_index,omitempty"` + TeamName *string `protobuf:"bytes,3,opt,name=team_name" json:"team_name,omitempty"` + TeamLogo *uint64 `protobuf:"varint,4,opt,name=team_logo" json:"team_logo,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEditFantasyTeamRequest) Reset() { *m = CMsgDOTAEditFantasyTeamRequest{} } +func (m *CMsgDOTAEditFantasyTeamRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEditFantasyTeamRequest) ProtoMessage() {} +func (*CMsgDOTAEditFantasyTeamRequest) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{13} } + +func (m *CMsgDOTAEditFantasyTeamRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAEditFantasyTeamRequest) GetTeamIndex() uint32 { + if m != nil && m.TeamIndex != nil { + return *m.TeamIndex + } + return 0 +} + +func (m *CMsgDOTAEditFantasyTeamRequest) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTAEditFantasyTeamRequest) GetTeamLogo() uint64 { + if m != nil && m.TeamLogo != nil { + return *m.TeamLogo + } + return 0 +} + +type CMsgDOTAEditFantasyTeamResponse struct { + Result *CMsgDOTAEditFantasyTeamResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAEditFantasyTeamResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAEditFantasyTeamResponse) Reset() { *m = CMsgDOTAEditFantasyTeamResponse{} } +func (m *CMsgDOTAEditFantasyTeamResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAEditFantasyTeamResponse) ProtoMessage() {} +func (*CMsgDOTAEditFantasyTeamResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{14} +} + +const Default_CMsgDOTAEditFantasyTeamResponse_Result CMsgDOTAEditFantasyTeamResponse_EResult = CMsgDOTAEditFantasyTeamResponse_SUCCESS + +func (m *CMsgDOTAEditFantasyTeamResponse) GetResult() CMsgDOTAEditFantasyTeamResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAEditFantasyTeamResponse_Result +} + +type CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID) Reset() { + *m = CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID{} +} +func (m *CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{15} +} + +func (m *CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID struct { + OwnerAccountId *uint32 `protobuf:"varint,1,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID) Reset() { + *m = CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID{} +} +func (m *CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{16} +} + +func (m *CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +type CMsgDOTAFantasyTeamInfoResponse struct { + Results []*CMsgDOTAFantasyTeamInfo `protobuf:"bytes,1,rep,name=results" json:"results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamInfoResponse) Reset() { *m = CMsgDOTAFantasyTeamInfoResponse{} } +func (m *CMsgDOTAFantasyTeamInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamInfoResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamInfoResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{17} +} + +func (m *CMsgDOTAFantasyTeamInfoResponse) GetResults() []*CMsgDOTAFantasyTeamInfo { + if m != nil { + return m.Results + } + return nil +} + +type CMsgDOTAFantasyTeamInfo struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + OwnerAccountId *uint32 `protobuf:"varint,2,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + FantasyTeamIndex *uint32 `protobuf:"varint,3,opt,name=fantasy_team_index" json:"fantasy_team_index,omitempty"` + TeamName *string `protobuf:"bytes,4,opt,name=team_name" json:"team_name,omitempty"` + TeamLogo *uint64 `protobuf:"varint,5,opt,name=team_logo" json:"team_logo,omitempty"` + Wins *uint32 `protobuf:"varint,6,opt,name=wins" json:"wins,omitempty"` + Losses *uint32 `protobuf:"varint,7,opt,name=losses" json:"losses,omitempty"` + CurrentRoster []uint32 `protobuf:"varint,8,rep,name=current_roster" json:"current_roster,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamInfo) Reset() { *m = CMsgDOTAFantasyTeamInfo{} } +func (m *CMsgDOTAFantasyTeamInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamInfo) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamInfo) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{18} } + +func (m *CMsgDOTAFantasyTeamInfo) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamInfo) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamInfo) GetFantasyTeamIndex() uint32 { + if m != nil && m.FantasyTeamIndex != nil { + return *m.FantasyTeamIndex + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamInfo) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTAFantasyTeamInfo) GetTeamLogo() uint64 { + if m != nil && m.TeamLogo != nil { + return *m.TeamLogo + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamInfo) GetWins() uint32 { + if m != nil && m.Wins != nil { + return *m.Wins + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamInfo) GetLosses() uint32 { + if m != nil && m.Losses != nil { + return *m.Losses + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamInfo) GetCurrentRoster() []uint32 { + if m != nil { + return m.CurrentRoster + } + return nil +} + +type CMsgDOTAFantasyTeamScoreRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + OwnerAccountId *uint32 `protobuf:"varint,2,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + FantasyTeamIndex *uint32 `protobuf:"varint,3,opt,name=fantasy_team_index" json:"fantasy_team_index,omitempty"` + FilterMatchId *uint64 `protobuf:"varint,4,opt,name=filter_match_id" json:"filter_match_id,omitempty"` + FilterStartTime *uint32 `protobuf:"varint,5,opt,name=filter_start_time" json:"filter_start_time,omitempty"` + FilterEndTime *uint32 `protobuf:"varint,6,opt,name=filter_end_time" json:"filter_end_time,omitempty"` + IncludeBench *bool `protobuf:"varint,7,opt,name=include_bench" json:"include_bench,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) Reset() { *m = CMsgDOTAFantasyTeamScoreRequest{} } +func (m *CMsgDOTAFantasyTeamScoreRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamScoreRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamScoreRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{19} +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) GetFantasyTeamIndex() uint32 { + if m != nil && m.FantasyTeamIndex != nil { + return *m.FantasyTeamIndex + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) GetFilterMatchId() uint64 { + if m != nil && m.FilterMatchId != nil { + return *m.FilterMatchId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) GetFilterStartTime() uint32 { + if m != nil && m.FilterStartTime != nil { + return *m.FilterStartTime + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) GetFilterEndTime() uint32 { + if m != nil && m.FilterEndTime != nil { + return *m.FilterEndTime + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreRequest) GetIncludeBench() bool { + if m != nil && m.IncludeBench != nil { + return *m.IncludeBench + } + return false +} + +type CMsgDOTAFantasyTeamScoreResponse struct { + Result *CMsgDOTAFantasyTeamScoreResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamScoreResponse_EResult,def=0" json:"result,omitempty"` + FantasyTeamScore *float32 `protobuf:"fixed32,2,opt,name=fantasy_team_score" json:"fantasy_team_score,omitempty"` + FantasyPlayerScore []*CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore `protobuf:"bytes,3,rep,name=fantasy_player_score" json:"fantasy_player_score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamScoreResponse) Reset() { *m = CMsgDOTAFantasyTeamScoreResponse{} } +func (m *CMsgDOTAFantasyTeamScoreResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamScoreResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamScoreResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{20} +} + +const Default_CMsgDOTAFantasyTeamScoreResponse_Result CMsgDOTAFantasyTeamScoreResponse_EResult = CMsgDOTAFantasyTeamScoreResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamScoreResponse) GetResult() CMsgDOTAFantasyTeamScoreResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamScoreResponse_Result +} + +func (m *CMsgDOTAFantasyTeamScoreResponse) GetFantasyTeamScore() float32 { + if m != nil && m.FantasyTeamScore != nil { + return *m.FantasyTeamScore + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreResponse) GetFantasyPlayerScore() []*CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore { + if m != nil { + return m.FantasyPlayerScore + } + return nil +} + +type CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Score *float32 `protobuf:"fixed32,2,opt,name=score" json:"score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore) Reset() { + *m = CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore{} +} +func (m *CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{20, 0} +} + +func (m *CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +type CMsgDOTAFantasyTeamStandingsRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Count *uint32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` + FilterStartTime *uint32 `protobuf:"varint,3,opt,name=filter_start_time" json:"filter_start_time,omitempty"` + FilterEndTime *uint32 `protobuf:"varint,4,opt,name=filter_end_time" json:"filter_end_time,omitempty"` + FilterMatchId *uint64 `protobuf:"varint,5,opt,name=filter_match_id" json:"filter_match_id,omitempty"` + FilterLastMatch *bool `protobuf:"varint,6,opt,name=filter_last_match" json:"filter_last_match,omitempty"` + FilterInHall *bool `protobuf:"varint,7,opt,name=filter_in_hall" json:"filter_in_hall,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) Reset() { *m = CMsgDOTAFantasyTeamStandingsRequest{} } +func (m *CMsgDOTAFantasyTeamStandingsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamStandingsRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamStandingsRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{21} +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) GetCount() uint32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) GetFilterStartTime() uint32 { + if m != nil && m.FilterStartTime != nil { + return *m.FilterStartTime + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) GetFilterEndTime() uint32 { + if m != nil && m.FilterEndTime != nil { + return *m.FilterEndTime + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) GetFilterMatchId() uint64 { + if m != nil && m.FilterMatchId != nil { + return *m.FilterMatchId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) GetFilterLastMatch() bool { + if m != nil && m.FilterLastMatch != nil { + return *m.FilterLastMatch + } + return false +} + +func (m *CMsgDOTAFantasyTeamStandingsRequest) GetFilterInHall() bool { + if m != nil && m.FilterInHall != nil { + return *m.FilterInHall + } + return false +} + +type CMsgDOTAFantasyTeamStandingsResponse struct { + Result *CMsgDOTAFantasyTeamStandingsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamStandingsResponse_EResult,def=0" json:"result,omitempty"` + TeamScores []*CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore `protobuf:"bytes,3,rep,name=team_scores" json:"team_scores,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse) Reset() { *m = CMsgDOTAFantasyTeamStandingsResponse{} } +func (m *CMsgDOTAFantasyTeamStandingsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamStandingsResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamStandingsResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{22} +} + +const Default_CMsgDOTAFantasyTeamStandingsResponse_Result CMsgDOTAFantasyTeamStandingsResponse_EResult = CMsgDOTAFantasyTeamStandingsResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamStandingsResponse) GetResult() CMsgDOTAFantasyTeamStandingsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamStandingsResponse_Result +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse) GetTeamScores() []*CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore { + if m != nil { + return m.TeamScores + } + return nil +} + +type CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + OwnerAccountId *uint32 `protobuf:"varint,2,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + FantasyTeamIndex *uint32 `protobuf:"varint,3,opt,name=fantasy_team_index" json:"fantasy_team_index,omitempty"` + FantasyTeamLogo *uint64 `protobuf:"varint,4,opt,name=fantasy_team_logo" json:"fantasy_team_logo,omitempty"` + OwnerName *string `protobuf:"bytes,5,opt,name=owner_name" json:"owner_name,omitempty"` + FantasyTeamName *string `protobuf:"bytes,6,opt,name=fantasy_team_name" json:"fantasy_team_name,omitempty"` + Score *float32 `protobuf:"fixed32,7,opt,name=score" json:"score,omitempty"` + ScoreAgainst *float32 `protobuf:"fixed32,8,opt,name=score_against" json:"score_against,omitempty"` + Wins *uint32 `protobuf:"varint,9,opt,name=wins" json:"wins,omitempty"` + Losses *uint32 `protobuf:"varint,10,opt,name=losses" json:"losses,omitempty"` + Streak *int32 `protobuf:"varint,11,opt,name=streak" json:"streak,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) Reset() { + *m = CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore{} +} +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{22, 0} +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetFantasyTeamIndex() uint32 { + if m != nil && m.FantasyTeamIndex != nil { + return *m.FantasyTeamIndex + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetFantasyTeamLogo() uint64 { + if m != nil && m.FantasyTeamLogo != nil { + return *m.FantasyTeamLogo + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetOwnerName() string { + if m != nil && m.OwnerName != nil { + return *m.OwnerName + } + return "" +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetFantasyTeamName() string { + if m != nil && m.FantasyTeamName != nil { + return *m.FantasyTeamName + } + return "" +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetScoreAgainst() float32 { + if m != nil && m.ScoreAgainst != nil { + return *m.ScoreAgainst + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetWins() uint32 { + if m != nil && m.Wins != nil { + return *m.Wins + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetLosses() uint32 { + if m != nil && m.Losses != nil { + return *m.Losses + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore) GetStreak() int32 { + if m != nil && m.Streak != nil { + return *m.Streak + } + return 0 +} + +type CMsgDOTAFantasyPlayerScoreRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + PlayerAccountId *uint32 `protobuf:"varint,2,opt,name=player_account_id" json:"player_account_id,omitempty"` + FilterStartTime *uint32 `protobuf:"varint,3,opt,name=filter_start_time" json:"filter_start_time,omitempty"` + FilterEndTime *uint32 `protobuf:"varint,4,opt,name=filter_end_time" json:"filter_end_time,omitempty"` + FilterMatchId *uint64 `protobuf:"varint,5,opt,name=filter_match_id" json:"filter_match_id,omitempty"` + FilterLastMatch *bool `protobuf:"varint,6,opt,name=filter_last_match" json:"filter_last_match,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerScoreRequest) Reset() { *m = CMsgDOTAFantasyPlayerScoreRequest{} } +func (m *CMsgDOTAFantasyPlayerScoreRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerScoreRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerScoreRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{23} +} + +func (m *CMsgDOTAFantasyPlayerScoreRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreRequest) GetPlayerAccountId() uint32 { + if m != nil && m.PlayerAccountId != nil { + return *m.PlayerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreRequest) GetFilterStartTime() uint32 { + if m != nil && m.FilterStartTime != nil { + return *m.FilterStartTime + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreRequest) GetFilterEndTime() uint32 { + if m != nil && m.FilterEndTime != nil { + return *m.FilterEndTime + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreRequest) GetFilterMatchId() uint64 { + if m != nil && m.FilterMatchId != nil { + return *m.FilterMatchId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreRequest) GetFilterLastMatch() bool { + if m != nil && m.FilterLastMatch != nil { + return *m.FilterLastMatch + } + return false +} + +type CMsgDOTAFantasyPlayerScoreResponse struct { + Result *CMsgDOTAFantasyPlayerScoreResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyPlayerScoreResponse_EResult,def=0" json:"result,omitempty"` + FantasyLeagueId *uint32 `protobuf:"varint,2,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + PlayerAccountId *uint32 `protobuf:"varint,3,opt,name=player_account_id" json:"player_account_id,omitempty"` + PlayerName *string `protobuf:"bytes,4,opt,name=player_name" json:"player_name,omitempty"` + Score *float32 `protobuf:"fixed32,5,opt,name=score" json:"score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerScoreResponse) Reset() { *m = CMsgDOTAFantasyPlayerScoreResponse{} } +func (m *CMsgDOTAFantasyPlayerScoreResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerScoreResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerScoreResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{24} +} + +const Default_CMsgDOTAFantasyPlayerScoreResponse_Result CMsgDOTAFantasyPlayerScoreResponse_EResult = CMsgDOTAFantasyPlayerScoreResponse_SUCCESS + +func (m *CMsgDOTAFantasyPlayerScoreResponse) GetResult() CMsgDOTAFantasyPlayerScoreResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyPlayerScoreResponse_Result +} + +func (m *CMsgDOTAFantasyPlayerScoreResponse) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreResponse) GetPlayerAccountId() uint32 { + if m != nil && m.PlayerAccountId != nil { + return *m.PlayerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreResponse) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +func (m *CMsgDOTAFantasyPlayerScoreResponse) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +type CMsgDOTAFantasyPlayerStandingsRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Count *uint32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` + Role *uint32 `protobuf:"varint,3,opt,name=role" json:"role,omitempty"` + FilterStartTime *uint32 `protobuf:"varint,4,opt,name=filter_start_time" json:"filter_start_time,omitempty"` + FilterEndTime *uint32 `protobuf:"varint,5,opt,name=filter_end_time" json:"filter_end_time,omitempty"` + FilterMatchId *uint64 `protobuf:"varint,6,opt,name=filter_match_id" json:"filter_match_id,omitempty"` + FilterLastMatch *bool `protobuf:"varint,7,opt,name=filter_last_match" json:"filter_last_match,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) Reset() { *m = CMsgDOTAFantasyPlayerStandingsRequest{} } +func (m *CMsgDOTAFantasyPlayerStandingsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerStandingsRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerStandingsRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{25} +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) GetCount() uint32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) GetRole() uint32 { + if m != nil && m.Role != nil { + return *m.Role + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) GetFilterStartTime() uint32 { + if m != nil && m.FilterStartTime != nil { + return *m.FilterStartTime + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) GetFilterEndTime() uint32 { + if m != nil && m.FilterEndTime != nil { + return *m.FilterEndTime + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) GetFilterMatchId() uint64 { + if m != nil && m.FilterMatchId != nil { + return *m.FilterMatchId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsRequest) GetFilterLastMatch() bool { + if m != nil && m.FilterLastMatch != nil { + return *m.FilterLastMatch + } + return false +} + +type CMsgDOTAFantasyPlayerStandingsResponse struct { + Result *CMsgDOTAFantasyPlayerStandingsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyPlayerStandingsResponse_EResult,def=0" json:"result,omitempty"` + FantasyLeagueId *uint32 `protobuf:"varint,2,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Role *uint32 `protobuf:"varint,3,opt,name=role" json:"role,omitempty"` + PlayerScores []*CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore `protobuf:"bytes,4,rep,name=player_scores" json:"player_scores,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse) Reset() { + *m = CMsgDOTAFantasyPlayerStandingsResponse{} +} +func (m *CMsgDOTAFantasyPlayerStandingsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerStandingsResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerStandingsResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{26} +} + +const Default_CMsgDOTAFantasyPlayerStandingsResponse_Result CMsgDOTAFantasyPlayerStandingsResponse_EResult = CMsgDOTAFantasyPlayerStandingsResponse_SUCCESS + +func (m *CMsgDOTAFantasyPlayerStandingsResponse) GetResult() CMsgDOTAFantasyPlayerStandingsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyPlayerStandingsResponse_Result +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse) GetRole() uint32 { + if m != nil && m.Role != nil { + return *m.Role + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse) GetPlayerScores() []*CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore { + if m != nil { + return m.PlayerScores + } + return nil +} + +type CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore struct { + PlayerAccountId *uint32 `protobuf:"varint,1,opt,name=player_account_id" json:"player_account_id,omitempty"` + PlayerName *string `protobuf:"bytes,2,opt,name=player_name" json:"player_name,omitempty"` + Score *float32 `protobuf:"fixed32,3,opt,name=score" json:"score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore) Reset() { + *m = CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore{} +} +func (m *CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{26, 0} +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore) GetPlayerAccountId() uint32 { + if m != nil && m.PlayerAccountId != nil { + return *m.PlayerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +func (m *CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +type CMsgDOTAFantasyPlayerInfoRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerInfoRequest) Reset() { *m = CMsgDOTAFantasyPlayerInfoRequest{} } +func (m *CMsgDOTAFantasyPlayerInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerInfoRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerInfoRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{27} +} + +type CMsgDOTAFantasyPlayerInfoResponse struct { + Msg *CMsgGCPlayerInfo `protobuf:"bytes,1,opt,name=msg" json:"msg,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerInfoResponse) Reset() { *m = CMsgDOTAFantasyPlayerInfoResponse{} } +func (m *CMsgDOTAFantasyPlayerInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerInfoResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerInfoResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{28} +} + +func (m *CMsgDOTAFantasyPlayerInfoResponse) GetMsg() *CMsgGCPlayerInfo { + if m != nil { + return m.Msg + } + return nil +} + +type CMsgDOTAFantasyLeagueCreateRequest struct { + SeasonId *uint32 `protobuf:"varint,1,opt,name=season_id" json:"season_id,omitempty"` + FantasyLeagueName *string `protobuf:"bytes,2,opt,name=fantasy_league_name" json:"fantasy_league_name,omitempty"` + Password *string `protobuf:"bytes,3,opt,name=password" json:"password,omitempty"` + TeamName *string `protobuf:"bytes,4,opt,name=team_name" json:"team_name,omitempty"` + Logo *uint64 `protobuf:"varint,5,opt,name=logo" json:"logo,omitempty"` + TicketItemId *uint64 `protobuf:"varint,6,opt,name=ticket_item_id" json:"ticket_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueCreateRequest) Reset() { *m = CMsgDOTAFantasyLeagueCreateRequest{} } +func (m *CMsgDOTAFantasyLeagueCreateRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueCreateRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueCreateRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{29} +} + +func (m *CMsgDOTAFantasyLeagueCreateRequest) GetSeasonId() uint32 { + if m != nil && m.SeasonId != nil { + return *m.SeasonId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueCreateRequest) GetFantasyLeagueName() string { + if m != nil && m.FantasyLeagueName != nil { + return *m.FantasyLeagueName + } + return "" +} + +func (m *CMsgDOTAFantasyLeagueCreateRequest) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CMsgDOTAFantasyLeagueCreateRequest) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTAFantasyLeagueCreateRequest) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueCreateRequest) GetTicketItemId() uint64 { + if m != nil && m.TicketItemId != nil { + return *m.TicketItemId + } + return 0 +} + +type CMsgDOTAFantasyLeagueCreateResponse struct { + Result *CMsgDOTAFantasyLeagueCreateResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeagueCreateResponse_EResult,def=0" json:"result,omitempty"` + FantasyLeagueId *uint32 `protobuf:"varint,2,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueCreateResponse) Reset() { *m = CMsgDOTAFantasyLeagueCreateResponse{} } +func (m *CMsgDOTAFantasyLeagueCreateResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueCreateResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueCreateResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{30} +} + +const Default_CMsgDOTAFantasyLeagueCreateResponse_Result CMsgDOTAFantasyLeagueCreateResponse_EResult = CMsgDOTAFantasyLeagueCreateResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeagueCreateResponse) GetResult() CMsgDOTAFantasyLeagueCreateResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeagueCreateResponse_Result +} + +func (m *CMsgDOTAFantasyLeagueCreateResponse) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyTeamCreateRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Password *string `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"` + TeamName *string `protobuf:"bytes,3,opt,name=team_name" json:"team_name,omitempty"` + Logo *uint64 `protobuf:"varint,4,opt,name=logo" json:"logo,omitempty"` + TicketItemId *uint64 `protobuf:"varint,5,opt,name=ticket_item_id" json:"ticket_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamCreateRequest) Reset() { *m = CMsgDOTAFantasyTeamCreateRequest{} } +func (m *CMsgDOTAFantasyTeamCreateRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamCreateRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamCreateRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{31} +} + +func (m *CMsgDOTAFantasyTeamCreateRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamCreateRequest) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CMsgDOTAFantasyTeamCreateRequest) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTAFantasyTeamCreateRequest) GetLogo() uint64 { + if m != nil && m.Logo != nil { + return *m.Logo + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamCreateRequest) GetTicketItemId() uint64 { + if m != nil && m.TicketItemId != nil { + return *m.TicketItemId + } + return 0 +} + +type CMsgDOTAFantasyTeamCreateResponse struct { + Result *CMsgDOTAFantasyTeamCreateResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamCreateResponse_EResult,def=0" json:"result,omitempty"` + FantasyTeamIndex *uint32 `protobuf:"varint,2,opt,name=fantasy_team_index" json:"fantasy_team_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamCreateResponse) Reset() { *m = CMsgDOTAFantasyTeamCreateResponse{} } +func (m *CMsgDOTAFantasyTeamCreateResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamCreateResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamCreateResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{32} +} + +const Default_CMsgDOTAFantasyTeamCreateResponse_Result CMsgDOTAFantasyTeamCreateResponse_EResult = CMsgDOTAFantasyTeamCreateResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamCreateResponse) GetResult() CMsgDOTAFantasyTeamCreateResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamCreateResponse_Result +} + +func (m *CMsgDOTAFantasyTeamCreateResponse) GetFantasyTeamIndex() uint32 { + if m != nil && m.FantasyTeamIndex != nil { + return *m.FantasyTeamIndex + } + return 0 +} + +type CMsgDOTAFantasyLeagueEditInvitesRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Password *string `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"` + InviteChange []*CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange `protobuf:"bytes,3,rep,name=invite_change" json:"invite_change,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest) Reset() { + *m = CMsgDOTAFantasyLeagueEditInvitesRequest{} +} +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueEditInvitesRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueEditInvitesRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{33} +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest) GetInviteChange() []*CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange { + if m != nil { + return m.InviteChange + } + return nil +} + +type CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Invited *bool `protobuf:"varint,2,opt,name=invited" json:"invited,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange) Reset() { + *m = CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange{} +} +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{33, 0} +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange) GetInvited() bool { + if m != nil && m.Invited != nil { + return *m.Invited + } + return false +} + +type CMsgDOTAFantasyLeagueEditInvitesResponse struct { + Result *CMsgDOTAFantasyLeagueEditInvitesResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeagueEditInvitesResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueEditInvitesResponse) Reset() { + *m = CMsgDOTAFantasyLeagueEditInvitesResponse{} +} +func (m *CMsgDOTAFantasyLeagueEditInvitesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueEditInvitesResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueEditInvitesResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{34} +} + +const Default_CMsgDOTAFantasyLeagueEditInvitesResponse_Result CMsgDOTAFantasyLeagueEditInvitesResponse_EResult = CMsgDOTAFantasyLeagueEditInvitesResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeagueEditInvitesResponse) GetResult() CMsgDOTAFantasyLeagueEditInvitesResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeagueEditInvitesResponse_Result +} + +type CMsgDOTAFantasyLeagueDraftStatusRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueDraftStatusRequest) Reset() { + *m = CMsgDOTAFantasyLeagueDraftStatusRequest{} +} +func (m *CMsgDOTAFantasyLeagueDraftStatusRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueDraftStatusRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueDraftStatusRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{35} +} + +func (m *CMsgDOTAFantasyLeagueDraftStatusRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyLeagueDraftStatus struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + DraftOrder []uint32 `protobuf:"varint,2,rep,name=draft_order" json:"draft_order,omitempty"` + CurrentPick *uint32 `protobuf:"varint,3,opt,name=current_pick" json:"current_pick,omitempty"` + TimeRemaining *uint32 `protobuf:"varint,4,opt,name=time_remaining" json:"time_remaining,omitempty"` + PendingResume *bool `protobuf:"varint,5,opt,name=pending_resume" json:"pending_resume,omitempty"` + Completed *bool `protobuf:"varint,6,opt,name=completed" json:"completed,omitempty"` + AvailablePlayers []uint32 `protobuf:"varint,7,rep,name=available_players" json:"available_players,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) Reset() { *m = CMsgDOTAFantasyLeagueDraftStatus{} } +func (m *CMsgDOTAFantasyLeagueDraftStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueDraftStatus) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueDraftStatus) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{36} +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) GetDraftOrder() []uint32 { + if m != nil { + return m.DraftOrder + } + return nil +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) GetCurrentPick() uint32 { + if m != nil && m.CurrentPick != nil { + return *m.CurrentPick + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) GetTimeRemaining() uint32 { + if m != nil && m.TimeRemaining != nil { + return *m.TimeRemaining + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) GetPendingResume() bool { + if m != nil && m.PendingResume != nil { + return *m.PendingResume + } + return false +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) GetCompleted() bool { + if m != nil && m.Completed != nil { + return *m.Completed + } + return false +} + +func (m *CMsgDOTAFantasyLeagueDraftStatus) GetAvailablePlayers() []uint32 { + if m != nil { + return m.AvailablePlayers + } + return nil +} + +type CMsgDOTAFantasyLeagueDraftPlayerRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + TeamIndex *uint32 `protobuf:"varint,2,opt,name=team_index" json:"team_index,omitempty"` + PlayerAccountId *uint32 `protobuf:"varint,3,opt,name=player_account_id" json:"player_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueDraftPlayerRequest) Reset() { + *m = CMsgDOTAFantasyLeagueDraftPlayerRequest{} +} +func (m *CMsgDOTAFantasyLeagueDraftPlayerRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueDraftPlayerRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueDraftPlayerRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{37} +} + +func (m *CMsgDOTAFantasyLeagueDraftPlayerRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueDraftPlayerRequest) GetTeamIndex() uint32 { + if m != nil && m.TeamIndex != nil { + return *m.TeamIndex + } + return 0 +} + +func (m *CMsgDOTAFantasyLeagueDraftPlayerRequest) GetPlayerAccountId() uint32 { + if m != nil && m.PlayerAccountId != nil { + return *m.PlayerAccountId + } + return 0 +} + +type CMsgDOTAFantasyLeagueDraftPlayerResponse struct { + Result *CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeagueDraftPlayerResponse) Reset() { + *m = CMsgDOTAFantasyLeagueDraftPlayerResponse{} +} +func (m *CMsgDOTAFantasyLeagueDraftPlayerResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeagueDraftPlayerResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeagueDraftPlayerResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{38} +} + +const Default_CMsgDOTAFantasyLeagueDraftPlayerResponse_Result CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult = CMsgDOTAFantasyLeagueDraftPlayerResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeagueDraftPlayerResponse) GetResult() CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeagueDraftPlayerResponse_Result +} + +type CMsgDOTAFantasyTeamRosterSwapRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + TeamIndex *uint32 `protobuf:"varint,2,opt,name=team_index" json:"team_index,omitempty"` + Timestamp *uint32 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` + Slot_1 *uint32 `protobuf:"varint,4,opt,name=slot_1" json:"slot_1,omitempty"` + Slot_2 *uint32 `protobuf:"varint,5,opt,name=slot_2" json:"slot_2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamRosterSwapRequest) Reset() { *m = CMsgDOTAFantasyTeamRosterSwapRequest{} } +func (m *CMsgDOTAFantasyTeamRosterSwapRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamRosterSwapRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamRosterSwapRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{39} +} + +func (m *CMsgDOTAFantasyTeamRosterSwapRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterSwapRequest) GetTeamIndex() uint32 { + if m != nil && m.TeamIndex != nil { + return *m.TeamIndex + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterSwapRequest) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterSwapRequest) GetSlot_1() uint32 { + if m != nil && m.Slot_1 != nil { + return *m.Slot_1 + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterSwapRequest) GetSlot_2() uint32 { + if m != nil && m.Slot_2 != nil { + return *m.Slot_2 + } + return 0 +} + +type CMsgDOTAFantasyTeamRosterSwapResponse struct { + Result *CMsgDOTAFantasyTeamRosterSwapResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamRosterSwapResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamRosterSwapResponse) Reset() { *m = CMsgDOTAFantasyTeamRosterSwapResponse{} } +func (m *CMsgDOTAFantasyTeamRosterSwapResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamRosterSwapResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamRosterSwapResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{40} +} + +const Default_CMsgDOTAFantasyTeamRosterSwapResponse_Result CMsgDOTAFantasyTeamRosterSwapResponse_EResult = CMsgDOTAFantasyTeamRosterSwapResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamRosterSwapResponse) GetResult() CMsgDOTAFantasyTeamRosterSwapResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamRosterSwapResponse_Result +} + +type CMsgDOTAFantasyTeamRosterAddDropRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + TeamIndex *uint32 `protobuf:"varint,2,opt,name=team_index" json:"team_index,omitempty"` + AddAccountId *uint32 `protobuf:"varint,5,opt,name=add_account_id" json:"add_account_id,omitempty"` + DropAccountId *uint32 `protobuf:"varint,6,opt,name=drop_account_id" json:"drop_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamRosterAddDropRequest) Reset() { + *m = CMsgDOTAFantasyTeamRosterAddDropRequest{} +} +func (m *CMsgDOTAFantasyTeamRosterAddDropRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamRosterAddDropRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamRosterAddDropRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{41} +} + +func (m *CMsgDOTAFantasyTeamRosterAddDropRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterAddDropRequest) GetTeamIndex() uint32 { + if m != nil && m.TeamIndex != nil { + return *m.TeamIndex + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterAddDropRequest) GetAddAccountId() uint32 { + if m != nil && m.AddAccountId != nil { + return *m.AddAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterAddDropRequest) GetDropAccountId() uint32 { + if m != nil && m.DropAccountId != nil { + return *m.DropAccountId + } + return 0 +} + +type CMsgDOTAFantasyTeamRosterAddDropResponse struct { + Result *CMsgDOTAFantasyTeamRosterAddDropResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamRosterAddDropResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamRosterAddDropResponse) Reset() { + *m = CMsgDOTAFantasyTeamRosterAddDropResponse{} +} +func (m *CMsgDOTAFantasyTeamRosterAddDropResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamRosterAddDropResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamRosterAddDropResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{42} +} + +const Default_CMsgDOTAFantasyTeamRosterAddDropResponse_Result CMsgDOTAFantasyTeamRosterAddDropResponse_EResult = CMsgDOTAFantasyTeamRosterAddDropResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamRosterAddDropResponse) GetResult() CMsgDOTAFantasyTeamRosterAddDropResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamRosterAddDropResponse_Result +} + +type CMsgDOTAFantasyTeamTradesRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamTradesRequest) Reset() { *m = CMsgDOTAFantasyTeamTradesRequest{} } +func (m *CMsgDOTAFantasyTeamTradesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamTradesRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamTradesRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{43} +} + +func (m *CMsgDOTAFantasyTeamTradesRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyTeamTradesResponse struct { + Result *CMsgDOTAFantasyTeamTradesResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamTradesResponse_EResult,def=0" json:"result,omitempty"` + Trades []*CMsgDOTAFantasyTeamTradesResponse_Trade `protobuf:"bytes,2,rep,name=trades" json:"trades,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamTradesResponse) Reset() { *m = CMsgDOTAFantasyTeamTradesResponse{} } +func (m *CMsgDOTAFantasyTeamTradesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamTradesResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamTradesResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{44} +} + +const Default_CMsgDOTAFantasyTeamTradesResponse_Result CMsgDOTAFantasyTeamTradesResponse_EResult = CMsgDOTAFantasyTeamTradesResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamTradesResponse) GetResult() CMsgDOTAFantasyTeamTradesResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamTradesResponse_Result +} + +func (m *CMsgDOTAFantasyTeamTradesResponse) GetTrades() []*CMsgDOTAFantasyTeamTradesResponse_Trade { + if m != nil { + return m.Trades + } + return nil +} + +type CMsgDOTAFantasyTeamTradesResponse_Trade struct { + Timestamp *uint32 `protobuf:"varint,1,opt,name=timestamp" json:"timestamp,omitempty"` + OwnerAccountId_1 *uint32 `protobuf:"varint,2,opt,name=owner_account_id_1" json:"owner_account_id_1,omitempty"` + OwnerAccountId_2 *uint32 `protobuf:"varint,3,opt,name=owner_account_id_2" json:"owner_account_id_2,omitempty"` + PlayerAccountId_1 *uint32 `protobuf:"varint,4,opt,name=player_account_id_1" json:"player_account_id_1,omitempty"` + PlayerAccountId_2 *uint32 `protobuf:"varint,5,opt,name=player_account_id_2" json:"player_account_id_2,omitempty"` + Status *uint32 `protobuf:"varint,6,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) Reset() { + *m = CMsgDOTAFantasyTeamTradesResponse_Trade{} +} +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamTradesResponse_Trade) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamTradesResponse_Trade) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{44, 0} +} + +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) GetOwnerAccountId_1() uint32 { + if m != nil && m.OwnerAccountId_1 != nil { + return *m.OwnerAccountId_1 + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) GetOwnerAccountId_2() uint32 { + if m != nil && m.OwnerAccountId_2 != nil { + return *m.OwnerAccountId_2 + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) GetPlayerAccountId_1() uint32 { + if m != nil && m.PlayerAccountId_1 != nil { + return *m.PlayerAccountId_1 + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) GetPlayerAccountId_2() uint32 { + if m != nil && m.PlayerAccountId_2 != nil { + return *m.PlayerAccountId_2 + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradesResponse_Trade) GetStatus() uint32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CMsgDOTAFantasyTeamTradeCancelRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + TeamIndex_1 *uint32 `protobuf:"varint,3,opt,name=team_index_1" json:"team_index_1,omitempty"` + OwnerAccountId_2 *uint32 `protobuf:"varint,4,opt,name=owner_account_id_2" json:"owner_account_id_2,omitempty"` + TeamIndex_2 *uint32 `protobuf:"varint,5,opt,name=team_index_2" json:"team_index_2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamTradeCancelRequest) Reset() { *m = CMsgDOTAFantasyTeamTradeCancelRequest{} } +func (m *CMsgDOTAFantasyTeamTradeCancelRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamTradeCancelRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamTradeCancelRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{45} +} + +func (m *CMsgDOTAFantasyTeamTradeCancelRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradeCancelRequest) GetTeamIndex_1() uint32 { + if m != nil && m.TeamIndex_1 != nil { + return *m.TeamIndex_1 + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradeCancelRequest) GetOwnerAccountId_2() uint32 { + if m != nil && m.OwnerAccountId_2 != nil { + return *m.OwnerAccountId_2 + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamTradeCancelRequest) GetTeamIndex_2() uint32 { + if m != nil && m.TeamIndex_2 != nil { + return *m.TeamIndex_2 + } + return 0 +} + +type CMsgDOTAFantasyTeamTradeCancelResponse struct { + Result *CMsgDOTAFantasyTeamTradeCancelResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamTradeCancelResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamTradeCancelResponse) Reset() { + *m = CMsgDOTAFantasyTeamTradeCancelResponse{} +} +func (m *CMsgDOTAFantasyTeamTradeCancelResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamTradeCancelResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamTradeCancelResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{46} +} + +const Default_CMsgDOTAFantasyTeamTradeCancelResponse_Result CMsgDOTAFantasyTeamTradeCancelResponse_EResult = CMsgDOTAFantasyTeamTradeCancelResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamTradeCancelResponse) GetResult() CMsgDOTAFantasyTeamTradeCancelResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamTradeCancelResponse_Result +} + +type CMsgDOTAFantasyTeamRosterRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + TeamIndex *uint32 `protobuf:"varint,2,opt,name=team_index" json:"team_index,omitempty"` + OwnerAccountId *uint32 `protobuf:"varint,3,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + Timestamp *uint32 `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamRosterRequest) Reset() { *m = CMsgDOTAFantasyTeamRosterRequest{} } +func (m *CMsgDOTAFantasyTeamRosterRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamRosterRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamRosterRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{47} +} + +func (m *CMsgDOTAFantasyTeamRosterRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterRequest) GetTeamIndex() uint32 { + if m != nil && m.TeamIndex != nil { + return *m.TeamIndex + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterRequest) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyTeamRosterRequest) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +type CMsgDOTAFantasyTeamRosterResponse struct { + Result *CMsgDOTAFantasyTeamRosterResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyTeamRosterResponse_EResult,def=0" json:"result,omitempty"` + PlayerAccountIds []uint32 `protobuf:"varint,2,rep,name=player_account_ids" json:"player_account_ids,omitempty"` + PlayerLocked []bool `protobuf:"varint,3,rep,name=player_locked" json:"player_locked,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyTeamRosterResponse) Reset() { *m = CMsgDOTAFantasyTeamRosterResponse{} } +func (m *CMsgDOTAFantasyTeamRosterResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyTeamRosterResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyTeamRosterResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{48} +} + +const Default_CMsgDOTAFantasyTeamRosterResponse_Result CMsgDOTAFantasyTeamRosterResponse_EResult = CMsgDOTAFantasyTeamRosterResponse_SUCCESS + +func (m *CMsgDOTAFantasyTeamRosterResponse) GetResult() CMsgDOTAFantasyTeamRosterResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyTeamRosterResponse_Result +} + +func (m *CMsgDOTAFantasyTeamRosterResponse) GetPlayerAccountIds() []uint32 { + if m != nil { + return m.PlayerAccountIds + } + return nil +} + +func (m *CMsgDOTAFantasyTeamRosterResponse) GetPlayerLocked() []bool { + if m != nil { + return m.PlayerLocked + } + return nil +} + +type CMsgDOTAFantasyPlayerHisoricalStatsRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsRequest) Reset() { + *m = CMsgDOTAFantasyPlayerHisoricalStatsRequest{} +} +func (m *CMsgDOTAFantasyPlayerHisoricalStatsRequest) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyPlayerHisoricalStatsRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerHisoricalStatsRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{49} +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyPlayerHisoricalStatsResponse struct { + Result *CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult,def=0" json:"result,omitempty"` + Stats []*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats `protobuf:"bytes,2,rep,name=stats" json:"stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse) Reset() { + *m = CMsgDOTAFantasyPlayerHisoricalStatsResponse{} +} +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyPlayerHisoricalStatsResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerHisoricalStatsResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{50} +} + +const Default_CMsgDOTAFantasyPlayerHisoricalStatsResponse_Result CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult = CMsgDOTAFantasyPlayerHisoricalStatsResponse_SUCCESS + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse) GetResult() CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyPlayerHisoricalStatsResponse_Result +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse) GetStats() []*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats { + if m != nil { + return m.Stats + } + return nil +} + +type CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator struct { + Matches *uint32 `protobuf:"varint,1,opt,name=matches" json:"matches,omitempty"` + Levels *float32 `protobuf:"fixed32,2,opt,name=levels" json:"levels,omitempty"` + Kills *float32 `protobuf:"fixed32,3,opt,name=kills" json:"kills,omitempty"` + Deaths *float32 `protobuf:"fixed32,4,opt,name=deaths" json:"deaths,omitempty"` + Assists *float32 `protobuf:"fixed32,5,opt,name=assists" json:"assists,omitempty"` + LastHits *float32 `protobuf:"fixed32,6,opt,name=last_hits" json:"last_hits,omitempty"` + Denies *float32 `protobuf:"fixed32,7,opt,name=denies" json:"denies,omitempty"` + Gpm *float32 `protobuf:"fixed32,8,opt,name=gpm" json:"gpm,omitempty"` + Xppm *float32 `protobuf:"fixed32,9,opt,name=xppm" json:"xppm,omitempty"` + Stuns *float32 `protobuf:"fixed32,10,opt,name=stuns" json:"stuns,omitempty"` + Healing *float32 `protobuf:"fixed32,11,opt,name=healing" json:"healing,omitempty"` + TowerKills *float32 `protobuf:"fixed32,12,opt,name=tower_kills" json:"tower_kills,omitempty"` + RoshanKills *float32 `protobuf:"fixed32,13,opt,name=roshan_kills" json:"roshan_kills,omitempty"` + Score *float32 `protobuf:"fixed32,14,opt,name=score" json:"score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) Reset() { + *m = CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator{} +} +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{50, 0} +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetMatches() uint32 { + if m != nil && m.Matches != nil { + return *m.Matches + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetLevels() float32 { + if m != nil && m.Levels != nil { + return *m.Levels + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetKills() float32 { + if m != nil && m.Kills != nil { + return *m.Kills + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetDeaths() float32 { + if m != nil && m.Deaths != nil { + return *m.Deaths + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetAssists() float32 { + if m != nil && m.Assists != nil { + return *m.Assists + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetLastHits() float32 { + if m != nil && m.LastHits != nil { + return *m.LastHits + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetDenies() float32 { + if m != nil && m.Denies != nil { + return *m.Denies + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetGpm() float32 { + if m != nil && m.Gpm != nil { + return *m.Gpm + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetXppm() float32 { + if m != nil && m.Xppm != nil { + return *m.Xppm + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetStuns() float32 { + if m != nil && m.Stuns != nil { + return *m.Stuns + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetHealing() float32 { + if m != nil && m.Healing != nil { + return *m.Healing + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetTowerKills() float32 { + if m != nil && m.TowerKills != nil { + return *m.TowerKills + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetRoshanKills() float32 { + if m != nil && m.RoshanKills != nil { + return *m.RoshanKills + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +type CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Weeks *uint32 `protobuf:"varint,2,opt,name=weeks" json:"weeks,omitempty"` + StatsPremium *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator `protobuf:"bytes,4,opt,name=stats_premium" json:"stats_premium,omitempty"` + StatsProfessional *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator `protobuf:"bytes,5,opt,name=stats_professional" json:"stats_professional,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) Reset() { + *m = CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats{} +} +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{50, 1} +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) GetWeeks() uint32 { + if m != nil && m.Weeks != nil { + return *m.Weeks + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) GetStatsPremium() *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator { + if m != nil { + return m.StatsPremium + } + return nil +} + +func (m *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats) GetStatsProfessional() *CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator { + if m != nil { + return m.StatsProfessional + } + return nil +} + +type CMsgDOTAFantasyMessageAdd struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyMessageAdd) Reset() { *m = CMsgDOTAFantasyMessageAdd{} } +func (m *CMsgDOTAFantasyMessageAdd) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyMessageAdd) ProtoMessage() {} +func (*CMsgDOTAFantasyMessageAdd) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{51} } + +func (m *CMsgDOTAFantasyMessageAdd) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyMessageAdd) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +type CMsgDOTAFantasyMessagesRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + StartMessage *uint32 `protobuf:"varint,2,opt,name=start_message" json:"start_message,omitempty"` + EndMessage *uint32 `protobuf:"varint,3,opt,name=end_message" json:"end_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyMessagesRequest) Reset() { *m = CMsgDOTAFantasyMessagesRequest{} } +func (m *CMsgDOTAFantasyMessagesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyMessagesRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyMessagesRequest) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{52} } + +func (m *CMsgDOTAFantasyMessagesRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyMessagesRequest) GetStartMessage() uint32 { + if m != nil && m.StartMessage != nil { + return *m.StartMessage + } + return 0 +} + +func (m *CMsgDOTAFantasyMessagesRequest) GetEndMessage() uint32 { + if m != nil && m.EndMessage != nil { + return *m.EndMessage + } + return 0 +} + +type CMsgDOTAFantasyMessagesResponse struct { + Result *CMsgDOTAFantasyMessagesResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyMessagesResponse_EResult,def=0" json:"result,omitempty"` + Messages []*CMsgDOTAFantasyMessagesResponse_Message `protobuf:"bytes,2,rep,name=messages" json:"messages,omitempty"` + NumTotalMessages *uint32 `protobuf:"varint,3,opt,name=num_total_messages" json:"num_total_messages,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyMessagesResponse) Reset() { *m = CMsgDOTAFantasyMessagesResponse{} } +func (m *CMsgDOTAFantasyMessagesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyMessagesResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyMessagesResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{53} +} + +const Default_CMsgDOTAFantasyMessagesResponse_Result CMsgDOTAFantasyMessagesResponse_EResult = CMsgDOTAFantasyMessagesResponse_SUCCESS + +func (m *CMsgDOTAFantasyMessagesResponse) GetResult() CMsgDOTAFantasyMessagesResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyMessagesResponse_Result +} + +func (m *CMsgDOTAFantasyMessagesResponse) GetMessages() []*CMsgDOTAFantasyMessagesResponse_Message { + if m != nil { + return m.Messages + } + return nil +} + +func (m *CMsgDOTAFantasyMessagesResponse) GetNumTotalMessages() uint32 { + if m != nil && m.NumTotalMessages != nil { + return *m.NumTotalMessages + } + return 0 +} + +type CMsgDOTAFantasyMessagesResponse_Message struct { + MessageId *uint32 `protobuf:"varint,1,opt,name=message_id" json:"message_id,omitempty"` + Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"` + AuthorAccountId *uint32 `protobuf:"varint,3,opt,name=author_account_id" json:"author_account_id,omitempty"` + Time *uint32 `protobuf:"varint,4,opt,name=time" json:"time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyMessagesResponse_Message) Reset() { + *m = CMsgDOTAFantasyMessagesResponse_Message{} +} +func (m *CMsgDOTAFantasyMessagesResponse_Message) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyMessagesResponse_Message) ProtoMessage() {} +func (*CMsgDOTAFantasyMessagesResponse_Message) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{53, 0} +} + +func (m *CMsgDOTAFantasyMessagesResponse_Message) GetMessageId() uint32 { + if m != nil && m.MessageId != nil { + return *m.MessageId + } + return 0 +} + +func (m *CMsgDOTAFantasyMessagesResponse_Message) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgDOTAFantasyMessagesResponse_Message) GetAuthorAccountId() uint32 { + if m != nil && m.AuthorAccountId != nil { + return *m.AuthorAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyMessagesResponse_Message) GetTime() uint32 { + if m != nil && m.Time != nil { + return *m.Time + } + return 0 +} + +type CMsgDOTAFantasyRemoveOwner struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + OwnerAccountId *uint32 `protobuf:"varint,2,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + TeamIndex *uint32 `protobuf:"varint,3,opt,name=team_index" json:"team_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyRemoveOwner) Reset() { *m = CMsgDOTAFantasyRemoveOwner{} } +func (m *CMsgDOTAFantasyRemoveOwner) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyRemoveOwner) ProtoMessage() {} +func (*CMsgDOTAFantasyRemoveOwner) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{54} } + +func (m *CMsgDOTAFantasyRemoveOwner) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyRemoveOwner) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyRemoveOwner) GetTeamIndex() uint32 { + if m != nil && m.TeamIndex != nil { + return *m.TeamIndex + } + return 0 +} + +type CMsgDOTAFantasyRemoveOwnerResponse struct { + Result *CMsgDOTAFantasyRemoveOwnerResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyRemoveOwnerResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyRemoveOwnerResponse) Reset() { *m = CMsgDOTAFantasyRemoveOwnerResponse{} } +func (m *CMsgDOTAFantasyRemoveOwnerResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyRemoveOwnerResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyRemoveOwnerResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{55} +} + +const Default_CMsgDOTAFantasyRemoveOwnerResponse_Result CMsgDOTAFantasyRemoveOwnerResponse_EResult = CMsgDOTAFantasyRemoveOwnerResponse_SUCCESS + +func (m *CMsgDOTAFantasyRemoveOwnerResponse) GetResult() CMsgDOTAFantasyRemoveOwnerResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyRemoveOwnerResponse_Result +} + +type CMsgDOTAFantasyScheduledMatchesRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyScheduledMatchesRequest) Reset() { + *m = CMsgDOTAFantasyScheduledMatchesRequest{} +} +func (m *CMsgDOTAFantasyScheduledMatchesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyScheduledMatchesRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyScheduledMatchesRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{56} +} + +func (m *CMsgDOTAFantasyScheduledMatchesRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAFantasyScheduledMatchesResponse struct { + Result *CMsgDOTAFantasyScheduledMatchesResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyScheduledMatchesResponse_EResult,def=0" json:"result,omitempty"` + ScheduledMatchDays []*CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays `protobuf:"bytes,2,rep,name=scheduled_match_days" json:"scheduled_match_days,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyScheduledMatchesResponse) Reset() { + *m = CMsgDOTAFantasyScheduledMatchesResponse{} +} +func (m *CMsgDOTAFantasyScheduledMatchesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyScheduledMatchesResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyScheduledMatchesResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{57} +} + +const Default_CMsgDOTAFantasyScheduledMatchesResponse_Result CMsgDOTAFantasyScheduledMatchesResponse_EResult = CMsgDOTAFantasyScheduledMatchesResponse_SUCCESS + +func (m *CMsgDOTAFantasyScheduledMatchesResponse) GetResult() CMsgDOTAFantasyScheduledMatchesResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyScheduledMatchesResponse_Result +} + +func (m *CMsgDOTAFantasyScheduledMatchesResponse) GetScheduledMatchDays() []*CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays { + if m != nil { + return m.ScheduledMatchDays + } + return nil +} + +type CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays struct { + Timestamp *uint32 `protobuf:"varint,1,opt,name=timestamp" json:"timestamp,omitempty"` + TeamIds []uint32 `protobuf:"varint,2,rep,name=team_ids" json:"team_ids,omitempty"` + LeagueIds []uint32 `protobuf:"varint,3,rep,name=league_ids" json:"league_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays) Reset() { + *m = CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays{} +} +func (m *CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays) ProtoMessage() {} +func (*CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{57, 0} +} + +func (m *CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays) GetTeamIds() []uint32 { + if m != nil { + return m.TeamIds + } + return nil +} + +func (m *CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays) GetLeagueIds() []uint32 { + if m != nil { + return m.LeagueIds + } + return nil +} + +type CMsgDOTAFantasyLeaveLeagueRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + FantasyTeamIndex *uint32 `protobuf:"varint,2,opt,name=fantasy_team_index" json:"fantasy_team_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeaveLeagueRequest) Reset() { *m = CMsgDOTAFantasyLeaveLeagueRequest{} } +func (m *CMsgDOTAFantasyLeaveLeagueRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeaveLeagueRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyLeaveLeagueRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{58} +} + +func (m *CMsgDOTAFantasyLeaveLeagueRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyLeaveLeagueRequest) GetFantasyTeamIndex() uint32 { + if m != nil && m.FantasyTeamIndex != nil { + return *m.FantasyTeamIndex + } + return 0 +} + +type CMsgDOTAFantasyLeaveLeagueResponse struct { + Result *CMsgDOTAFantasyLeaveLeagueResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyLeaveLeagueResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyLeaveLeagueResponse) Reset() { *m = CMsgDOTAFantasyLeaveLeagueResponse{} } +func (m *CMsgDOTAFantasyLeaveLeagueResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyLeaveLeagueResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyLeaveLeagueResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{59} +} + +const Default_CMsgDOTAFantasyLeaveLeagueResponse_Result CMsgDOTAFantasyLeaveLeagueResponse_EResult = CMsgDOTAFantasyLeaveLeagueResponse_SUCCESS + +func (m *CMsgDOTAFantasyLeaveLeagueResponse) GetResult() CMsgDOTAFantasyLeaveLeagueResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyLeaveLeagueResponse_Result +} + +type CMsgDOTAFantasyPlayerScoreDetailsRequest struct { + FantasyLeagueId *uint32 `protobuf:"varint,1,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + PlayerAccountId *uint32 `protobuf:"varint,2,opt,name=player_account_id" json:"player_account_id,omitempty"` + StartTime *uint32 `protobuf:"varint,3,opt,name=start_time" json:"start_time,omitempty"` + EndTime *uint32 `protobuf:"varint,4,opt,name=end_time" json:"end_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsRequest) Reset() { + *m = CMsgDOTAFantasyPlayerScoreDetailsRequest{} +} +func (m *CMsgDOTAFantasyPlayerScoreDetailsRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerScoreDetailsRequest) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerScoreDetailsRequest) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{60} +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsRequest) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsRequest) GetPlayerAccountId() uint32 { + if m != nil && m.PlayerAccountId != nil { + return *m.PlayerAccountId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsRequest) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsRequest) GetEndTime() uint32 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +type CMsgDOTAFantasyPlayerScoreDetailsResponse struct { + Result *CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult,def=0" json:"result,omitempty"` + Data []*CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData `protobuf:"bytes,2,rep,name=data" json:"data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse) Reset() { + *m = CMsgDOTAFantasyPlayerScoreDetailsResponse{} +} +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAFantasyPlayerScoreDetailsResponse) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerScoreDetailsResponse) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{61} +} + +const Default_CMsgDOTAFantasyPlayerScoreDetailsResponse_Result CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult = CMsgDOTAFantasyPlayerScoreDetailsResponse_SUCCESS + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse) GetResult() CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTAFantasyPlayerScoreDetailsResponse_Result +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse) GetData() []*CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData { + if m != nil { + return m.Data + } + return nil +} + +type CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + SeriesId *uint32 `protobuf:"varint,2,opt,name=series_id" json:"series_id,omitempty"` + SeriesNum *uint32 `protobuf:"varint,3,opt,name=series_num" json:"series_num,omitempty"` + SeriesType *uint32 `protobuf:"varint,4,opt,name=series_type" json:"series_type,omitempty"` + LeagueTier *uint32 `protobuf:"varint,5,opt,name=league_tier" json:"league_tier,omitempty"` + LeagueId *uint32 `protobuf:"varint,6,opt,name=league_id" json:"league_id,omitempty"` + OpposingTeamId *uint32 `protobuf:"varint,7,opt,name=opposing_team_id" json:"opposing_team_id,omitempty"` + OpposingTeamLogo *uint64 `protobuf:"varint,8,opt,name=opposing_team_logo" json:"opposing_team_logo,omitempty"` + OpposingTeamName *string `protobuf:"bytes,9,opt,name=opposing_team_name" json:"opposing_team_name,omitempty"` + Stats *CMsgFantasyLeagueScoring `protobuf:"bytes,10,opt,name=stats" json:"stats,omitempty"` + OwnedBy *uint32 `protobuf:"varint,11,opt,name=owned_by" json:"owned_by,omitempty"` + Benched *bool `protobuf:"varint,12,opt,name=benched" json:"benched,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) Reset() { + *m = CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData{} +} +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) ProtoMessage() {} +func (*CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{61, 0} +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetSeriesId() uint32 { + if m != nil && m.SeriesId != nil { + return *m.SeriesId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetSeriesNum() uint32 { + if m != nil && m.SeriesNum != nil { + return *m.SeriesNum + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetLeagueTier() uint32 { + if m != nil && m.LeagueTier != nil { + return *m.LeagueTier + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetOpposingTeamId() uint32 { + if m != nil && m.OpposingTeamId != nil { + return *m.OpposingTeamId + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetOpposingTeamLogo() uint64 { + if m != nil && m.OpposingTeamLogo != nil { + return *m.OpposingTeamLogo + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetOpposingTeamName() string { + if m != nil && m.OpposingTeamName != nil { + return *m.OpposingTeamName + } + return "" +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetStats() *CMsgFantasyLeagueScoring { + if m != nil { + return m.Stats + } + return nil +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetOwnedBy() uint32 { + if m != nil && m.OwnedBy != nil { + return *m.OwnedBy + } + return 0 +} + +func (m *CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData) GetBenched() bool { + if m != nil && m.Benched != nil { + return *m.Benched + } + return false +} + +type CMsgDOTATournament struct { + Teams []*CMsgDOTATournament_Team `protobuf:"bytes,1,rep,name=teams" json:"teams,omitempty"` + Games []*CMsgDOTATournament_Game `protobuf:"bytes,2,rep,name=games" json:"games,omitempty"` + Gid *uint64 `protobuf:"varint,3,opt,name=gid" json:"gid,omitempty"` + TournamentId *uint32 `protobuf:"varint,4,opt,name=tournament_id" json:"tournament_id,omitempty"` + TournamentType *ETournamentType `protobuf:"varint,5,opt,name=tournament_type,enum=ETournamentType,def=0" json:"tournament_type,omitempty"` + TournamentTemplate *ETournamentTemplate `protobuf:"varint,6,opt,name=tournament_template,enum=ETournamentTemplate,def=0" json:"tournament_template,omitempty"` + LeagueId *uint32 `protobuf:"varint,7,opt,name=league_id" json:"league_id,omitempty"` + StartTime *uint32 `protobuf:"varint,8,opt,name=start_time" json:"start_time,omitempty"` + State *ETournamentState `protobuf:"varint,9,opt,name=state,enum=ETournamentState,def=0" json:"state,omitempty"` + Nodes []*CMsgDOTATournament_Node `protobuf:"bytes,10,rep,name=nodes" json:"nodes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATournament) Reset() { *m = CMsgDOTATournament{} } +func (m *CMsgDOTATournament) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATournament) ProtoMessage() {} +func (*CMsgDOTATournament) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{62} } + +const Default_CMsgDOTATournament_TournamentType ETournamentType = ETournamentType_k_ETournamentType_Unknown +const Default_CMsgDOTATournament_TournamentTemplate ETournamentTemplate = ETournamentTemplate_k_ETournamentTemplate_None +const Default_CMsgDOTATournament_State ETournamentState = ETournamentState_k_ETournamentState_Unknown + +func (m *CMsgDOTATournament) GetTeams() []*CMsgDOTATournament_Team { + if m != nil { + return m.Teams + } + return nil +} + +func (m *CMsgDOTATournament) GetGames() []*CMsgDOTATournament_Game { + if m != nil { + return m.Games + } + return nil +} + +func (m *CMsgDOTATournament) GetGid() uint64 { + if m != nil && m.Gid != nil { + return *m.Gid + } + return 0 +} + +func (m *CMsgDOTATournament) GetTournamentId() uint32 { + if m != nil && m.TournamentId != nil { + return *m.TournamentId + } + return 0 +} + +func (m *CMsgDOTATournament) GetTournamentType() ETournamentType { + if m != nil && m.TournamentType != nil { + return *m.TournamentType + } + return Default_CMsgDOTATournament_TournamentType +} + +func (m *CMsgDOTATournament) GetTournamentTemplate() ETournamentTemplate { + if m != nil && m.TournamentTemplate != nil { + return *m.TournamentTemplate + } + return Default_CMsgDOTATournament_TournamentTemplate +} + +func (m *CMsgDOTATournament) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTATournament) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgDOTATournament) GetState() ETournamentState { + if m != nil && m.State != nil { + return *m.State + } + return Default_CMsgDOTATournament_State +} + +func (m *CMsgDOTATournament) GetNodes() []*CMsgDOTATournament_Node { + if m != nil { + return m.Nodes + } + return nil +} + +type CMsgDOTATournament_Team struct { + TeamId *uint32 `protobuf:"varint,1,opt,name=team_id" json:"team_id,omitempty"` + TeamName *string `protobuf:"bytes,2,opt,name=team_name" json:"team_name,omitempty"` + TeamAbbrev *string `protobuf:"bytes,3,opt,name=team_abbrev" json:"team_abbrev,omitempty"` + Players []uint32 `protobuf:"varint,4,rep,packed,name=players" json:"players,omitempty"` + Seed *uint32 `protobuf:"varint,5,opt,name=seed" json:"seed,omitempty"` + TeamLogo *uint64 `protobuf:"varint,6,opt,name=team_logo" json:"team_logo,omitempty"` + CountryCode *string `protobuf:"bytes,7,opt,name=country_code" json:"country_code,omitempty"` + NodeOrState *uint32 `protobuf:"varint,8,opt,name=node_or_state" json:"node_or_state,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATournament_Team) Reset() { *m = CMsgDOTATournament_Team{} } +func (m *CMsgDOTATournament_Team) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATournament_Team) ProtoMessage() {} +func (*CMsgDOTATournament_Team) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{62, 0} } + +func (m *CMsgDOTATournament_Team) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTATournament_Team) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTATournament_Team) GetTeamAbbrev() string { + if m != nil && m.TeamAbbrev != nil { + return *m.TeamAbbrev + } + return "" +} + +func (m *CMsgDOTATournament_Team) GetPlayers() []uint32 { + if m != nil { + return m.Players + } + return nil +} + +func (m *CMsgDOTATournament_Team) GetSeed() uint32 { + if m != nil && m.Seed != nil { + return *m.Seed + } + return 0 +} + +func (m *CMsgDOTATournament_Team) GetTeamLogo() uint64 { + if m != nil && m.TeamLogo != nil { + return *m.TeamLogo + } + return 0 +} + +func (m *CMsgDOTATournament_Team) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgDOTATournament_Team) GetNodeOrState() uint32 { + if m != nil && m.NodeOrState != nil { + return *m.NodeOrState + } + return 0 +} + +type CMsgDOTATournament_Game struct { + GameId *uint32 `protobuf:"varint,1,opt,name=game_id" json:"game_id,omitempty"` + GoodTeamId *uint32 `protobuf:"varint,2,opt,name=good_team_id" json:"good_team_id,omitempty"` + BadTeamId *uint32 `protobuf:"varint,3,opt,name=bad_team_id" json:"bad_team_id,omitempty"` + GoodTeamSeed *uint32 `protobuf:"varint,12,opt,name=good_team_seed" json:"good_team_seed,omitempty"` + BadTeamSeed *uint32 `protobuf:"varint,13,opt,name=bad_team_seed" json:"bad_team_seed,omitempty"` + LobbyId *uint64 `protobuf:"fixed64,4,opt,name=lobby_id" json:"lobby_id,omitempty"` + MatchId *uint64 `protobuf:"varint,5,opt,name=match_id" json:"match_id,omitempty"` + GameName *string `protobuf:"bytes,6,opt,name=game_name" json:"game_name,omitempty"` + LiveStream *bool `protobuf:"varint,7,opt,name=live_stream" json:"live_stream,omitempty"` + Message *string `protobuf:"bytes,9,opt,name=message" json:"message,omitempty"` + ResultsFinal *bool `protobuf:"varint,10,opt,name=results_final" json:"results_final,omitempty"` + State *ETournamentGameState `protobuf:"varint,14,opt,name=state,enum=ETournamentGameState,def=0" json:"state,omitempty"` + NodeId *uint32 `protobuf:"varint,15,opt,name=node_id" json:"node_id,omitempty"` + StartTime *uint32 `protobuf:"varint,16,opt,name=start_time" json:"start_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATournament_Game) Reset() { *m = CMsgDOTATournament_Game{} } +func (m *CMsgDOTATournament_Game) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATournament_Game) ProtoMessage() {} +func (*CMsgDOTATournament_Game) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{62, 1} } + +const Default_CMsgDOTATournament_Game_State ETournamentGameState = ETournamentGameState_k_ETournamentGameState_Unknown + +func (m *CMsgDOTATournament_Game) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetGoodTeamId() uint32 { + if m != nil && m.GoodTeamId != nil { + return *m.GoodTeamId + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetBadTeamId() uint32 { + if m != nil && m.BadTeamId != nil { + return *m.BadTeamId + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetGoodTeamSeed() uint32 { + if m != nil && m.GoodTeamSeed != nil { + return *m.GoodTeamSeed + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetBadTeamSeed() uint32 { + if m != nil && m.BadTeamSeed != nil { + return *m.BadTeamSeed + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetGameName() string { + if m != nil && m.GameName != nil { + return *m.GameName + } + return "" +} + +func (m *CMsgDOTATournament_Game) GetLiveStream() bool { + if m != nil && m.LiveStream != nil { + return *m.LiveStream + } + return false +} + +func (m *CMsgDOTATournament_Game) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgDOTATournament_Game) GetResultsFinal() bool { + if m != nil && m.ResultsFinal != nil { + return *m.ResultsFinal + } + return false +} + +func (m *CMsgDOTATournament_Game) GetState() ETournamentGameState { + if m != nil && m.State != nil { + return *m.State + } + return Default_CMsgDOTATournament_Game_State +} + +func (m *CMsgDOTATournament_Game) GetNodeId() uint32 { + if m != nil && m.NodeId != nil { + return *m.NodeId + } + return 0 +} + +func (m *CMsgDOTATournament_Game) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +type CMsgDOTATournament_Node struct { + NodeId *uint32 `protobuf:"varint,1,opt,name=node_id" json:"node_id,omitempty"` + TeamSeedA *uint32 `protobuf:"varint,2,opt,name=team_seed_a" json:"team_seed_a,omitempty"` + TeamSeedB *uint32 `protobuf:"varint,3,opt,name=team_seed_b" json:"team_seed_b,omitempty"` + WinnerNode *uint32 `protobuf:"varint,4,opt,name=winner_node" json:"winner_node,omitempty"` + LoserNode *uint32 `protobuf:"varint,5,opt,name=loser_node" json:"loser_node,omitempty"` + SeriesType *uint32 `protobuf:"varint,7,opt,name=series_type" json:"series_type,omitempty"` + NodeState *ETournamentNodeState `protobuf:"varint,8,opt,name=node_state,enum=ETournamentNodeState,def=0" json:"node_state,omitempty"` + SeriesId *uint32 `protobuf:"varint,9,opt,name=series_id" json:"series_id,omitempty"` + StartTime *uint32 `protobuf:"varint,16,opt,name=start_time" json:"start_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATournament_Node) Reset() { *m = CMsgDOTATournament_Node{} } +func (m *CMsgDOTATournament_Node) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATournament_Node) ProtoMessage() {} +func (*CMsgDOTATournament_Node) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{62, 2} } + +const Default_CMsgDOTATournament_Node_NodeState ETournamentNodeState = ETournamentNodeState_k_ETournamentNodeState_Unknown + +func (m *CMsgDOTATournament_Node) GetNodeId() uint32 { + if m != nil && m.NodeId != nil { + return *m.NodeId + } + return 0 +} + +func (m *CMsgDOTATournament_Node) GetTeamSeedA() uint32 { + if m != nil && m.TeamSeedA != nil { + return *m.TeamSeedA + } + return 0 +} + +func (m *CMsgDOTATournament_Node) GetTeamSeedB() uint32 { + if m != nil && m.TeamSeedB != nil { + return *m.TeamSeedB + } + return 0 +} + +func (m *CMsgDOTATournament_Node) GetWinnerNode() uint32 { + if m != nil && m.WinnerNode != nil { + return *m.WinnerNode + } + return 0 +} + +func (m *CMsgDOTATournament_Node) GetLoserNode() uint32 { + if m != nil && m.LoserNode != nil { + return *m.LoserNode + } + return 0 +} + +func (m *CMsgDOTATournament_Node) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +func (m *CMsgDOTATournament_Node) GetNodeState() ETournamentNodeState { + if m != nil && m.NodeState != nil { + return *m.NodeState + } + return Default_CMsgDOTATournament_Node_NodeState +} + +func (m *CMsgDOTATournament_Node) GetSeriesId() uint32 { + if m != nil && m.SeriesId != nil { + return *m.SeriesId + } + return 0 +} + +func (m *CMsgDOTATournament_Node) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +type CMsgDOTATournamentRequest struct { + TournamentId *uint32 `protobuf:"varint,1,opt,name=tournament_id" json:"tournament_id,omitempty"` + ClientTournamentGid *uint64 `protobuf:"varint,2,opt,name=client_tournament_gid" json:"client_tournament_gid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATournamentRequest) Reset() { *m = CMsgDOTATournamentRequest{} } +func (m *CMsgDOTATournamentRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATournamentRequest) ProtoMessage() {} +func (*CMsgDOTATournamentRequest) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{63} } + +func (m *CMsgDOTATournamentRequest) GetTournamentId() uint32 { + if m != nil && m.TournamentId != nil { + return *m.TournamentId + } + return 0 +} + +func (m *CMsgDOTATournamentRequest) GetClientTournamentGid() uint64 { + if m != nil && m.ClientTournamentGid != nil { + return *m.ClientTournamentGid + } + return 0 +} + +type CMsgDOTATournamentResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result,def=2" json:"result,omitempty"` + Tournament *CMsgDOTATournament `protobuf:"bytes,2,opt,name=tournament" json:"tournament,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTATournamentResponse) Reset() { *m = CMsgDOTATournamentResponse{} } +func (m *CMsgDOTATournamentResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTATournamentResponse) ProtoMessage() {} +func (*CMsgDOTATournamentResponse) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{64} } + +const Default_CMsgDOTATournamentResponse_Result uint32 = 2 + +func (m *CMsgDOTATournamentResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgDOTATournamentResponse_Result +} + +func (m *CMsgDOTATournamentResponse) GetTournament() *CMsgDOTATournament { + if m != nil { + return m.Tournament + } + return nil +} + +type CMsgDOTAClearTournamentGame struct { + TournamentId *uint32 `protobuf:"varint,1,opt,name=tournament_id" json:"tournament_id,omitempty"` + GameId *uint32 `protobuf:"varint,2,opt,name=game_id" json:"game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAClearTournamentGame) Reset() { *m = CMsgDOTAClearTournamentGame{} } +func (m *CMsgDOTAClearTournamentGame) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAClearTournamentGame) ProtoMessage() {} +func (*CMsgDOTAClearTournamentGame) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{65} } + +func (m *CMsgDOTAClearTournamentGame) GetTournamentId() uint32 { + if m != nil && m.TournamentId != nil { + return *m.TournamentId + } + return 0 +} + +func (m *CMsgDOTAClearTournamentGame) GetGameId() uint32 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +type CMsgDOTAPassportVoteTeamGuess struct { + LeagueId *uint32 `protobuf:"varint,1,opt,name=league_id" json:"league_id,omitempty"` + WinnerId *uint32 `protobuf:"varint,2,opt,name=winner_id" json:"winner_id,omitempty"` + RunnerupId *uint32 `protobuf:"varint,3,opt,name=runnerup_id" json:"runnerup_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPassportVoteTeamGuess) Reset() { *m = CMsgDOTAPassportVoteTeamGuess{} } +func (m *CMsgDOTAPassportVoteTeamGuess) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPassportVoteTeamGuess) ProtoMessage() {} +func (*CMsgDOTAPassportVoteTeamGuess) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{66} } + +func (m *CMsgDOTAPassportVoteTeamGuess) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTAPassportVoteTeamGuess) GetWinnerId() uint32 { + if m != nil && m.WinnerId != nil { + return *m.WinnerId + } + return 0 +} + +func (m *CMsgDOTAPassportVoteTeamGuess) GetRunnerupId() uint32 { + if m != nil && m.RunnerupId != nil { + return *m.RunnerupId + } + return 0 +} + +type CMsgDOTAPassportVoteGenericSelection struct { + SelectionIndex *DOTA_2013PassportSelectionIndices `protobuf:"varint,1,opt,name=selection_index,enum=DOTA_2013PassportSelectionIndices,def=0" json:"selection_index,omitempty"` + Selection *uint32 `protobuf:"varint,2,opt,name=selection" json:"selection,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPassportVoteGenericSelection) Reset() { *m = CMsgDOTAPassportVoteGenericSelection{} } +func (m *CMsgDOTAPassportVoteGenericSelection) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPassportVoteGenericSelection) ProtoMessage() {} +func (*CMsgDOTAPassportVoteGenericSelection) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{67} +} + +const Default_CMsgDOTAPassportVoteGenericSelection_SelectionIndex DOTA_2013PassportSelectionIndices = DOTA_2013PassportSelectionIndices_PP13_SEL_ALLSTAR_PLAYER_0 + +func (m *CMsgDOTAPassportVoteGenericSelection) GetSelectionIndex() DOTA_2013PassportSelectionIndices { + if m != nil && m.SelectionIndex != nil { + return *m.SelectionIndex + } + return Default_CMsgDOTAPassportVoteGenericSelection_SelectionIndex +} + +func (m *CMsgDOTAPassportVoteGenericSelection) GetSelection() uint32 { + if m != nil && m.Selection != nil { + return *m.Selection + } + return 0 +} + +type CMsgDOTAPassportStampedPlayer struct { + SteamId *uint64 `protobuf:"varint,1,opt,name=steam_id" json:"steam_id,omitempty"` + StampLevel *uint32 `protobuf:"varint,2,opt,name=stamp_level" json:"stamp_level,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPassportStampedPlayer) Reset() { *m = CMsgDOTAPassportStampedPlayer{} } +func (m *CMsgDOTAPassportStampedPlayer) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPassportStampedPlayer) ProtoMessage() {} +func (*CMsgDOTAPassportStampedPlayer) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{68} } + +func (m *CMsgDOTAPassportStampedPlayer) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgDOTAPassportStampedPlayer) GetStampLevel() uint32 { + if m != nil && m.StampLevel != nil { + return *m.StampLevel + } + return 0 +} + +type CMsgDOTAPassportPlayerCardChallenge struct { + ChallengeId *uint32 `protobuf:"varint,1,opt,name=challenge_id" json:"challenge_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPassportPlayerCardChallenge) Reset() { *m = CMsgDOTAPassportPlayerCardChallenge{} } +func (m *CMsgDOTAPassportPlayerCardChallenge) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPassportPlayerCardChallenge) ProtoMessage() {} +func (*CMsgDOTAPassportPlayerCardChallenge) Descriptor() ([]byte, []int) { + return dota_client_fantasy_fileDescriptor0, []int{69} +} + +func (m *CMsgDOTAPassportPlayerCardChallenge) GetChallengeId() uint32 { + if m != nil && m.ChallengeId != nil { + return *m.ChallengeId + } + return 0 +} + +type CMsgDOTAPassportVote struct { + TeamVotes []*CMsgDOTAPassportVoteTeamGuess `protobuf:"bytes,1,rep,name=team_votes" json:"team_votes,omitempty"` + GenericSelections []*CMsgDOTAPassportVoteGenericSelection `protobuf:"bytes,2,rep,name=generic_selections" json:"generic_selections,omitempty"` + StampedPlayers []*CMsgDOTAPassportStampedPlayer `protobuf:"bytes,3,rep,name=stamped_players" json:"stamped_players,omitempty"` + PlayerCardChallenges []*CMsgDOTAPassportPlayerCardChallenge `protobuf:"bytes,4,rep,name=player_card_challenges" json:"player_card_challenges,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPassportVote) Reset() { *m = CMsgDOTAPassportVote{} } +func (m *CMsgDOTAPassportVote) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPassportVote) ProtoMessage() {} +func (*CMsgDOTAPassportVote) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{70} } + +func (m *CMsgDOTAPassportVote) GetTeamVotes() []*CMsgDOTAPassportVoteTeamGuess { + if m != nil { + return m.TeamVotes + } + return nil +} + +func (m *CMsgDOTAPassportVote) GetGenericSelections() []*CMsgDOTAPassportVoteGenericSelection { + if m != nil { + return m.GenericSelections + } + return nil +} + +func (m *CMsgDOTAPassportVote) GetStampedPlayers() []*CMsgDOTAPassportStampedPlayer { + if m != nil { + return m.StampedPlayers + } + return nil +} + +func (m *CMsgDOTAPassportVote) GetPlayerCardChallenges() []*CMsgDOTAPassportPlayerCardChallenge { + if m != nil { + return m.PlayerCardChallenges + } + return nil +} + +type CMsgPassportDataRequest struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPassportDataRequest) Reset() { *m = CMsgPassportDataRequest{} } +func (m *CMsgPassportDataRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgPassportDataRequest) ProtoMessage() {} +func (*CMsgPassportDataRequest) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{71} } + +func (m *CMsgPassportDataRequest) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgPassportDataResponse struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Result *uint32 `protobuf:"varint,2,opt,name=result,def=2" json:"result,omitempty"` + International *CMsgDOTATournament `protobuf:"bytes,5,opt,name=international" json:"international,omitempty"` + EastQualifiersPredictEndTime *uint32 `protobuf:"varint,7,opt,name=east_qualifiers_predict_end_time" json:"east_qualifiers_predict_end_time,omitempty"` + WestQualifiersPredictEndTime *uint32 `protobuf:"varint,8,opt,name=west_qualifiers_predict_end_time" json:"west_qualifiers_predict_end_time,omitempty"` + AllstarMatchEndTime *uint32 `protobuf:"varint,9,opt,name=allstar_match_end_time" json:"allstar_match_end_time,omitempty"` + LeagueGuesses *CMsgDOTAPassportVote `protobuf:"bytes,6,opt,name=league_guesses" json:"league_guesses,omitempty"` + EastQualifiersWinnerTeamId *uint32 `protobuf:"varint,10,opt,name=east_qualifiers_winner_team_id" json:"east_qualifiers_winner_team_id,omitempty"` + EastQualifiersRunnerUpTeamId *uint32 `protobuf:"varint,11,opt,name=east_qualifiers_runner_up_team_id" json:"east_qualifiers_runner_up_team_id,omitempty"` + WestQualifiersWinnerTeamId *uint32 `protobuf:"varint,12,opt,name=west_qualifiers_winner_team_id" json:"west_qualifiers_winner_team_id,omitempty"` + WestQualifiersRunnerUpTeamId *uint32 `protobuf:"varint,13,opt,name=west_qualifiers_runner_up_team_id" json:"west_qualifiers_runner_up_team_id,omitempty"` + PassportsBought *uint32 `protobuf:"varint,14,opt,name=passports_bought" json:"passports_bought,omitempty"` + OriginalPurchaserId *uint32 `protobuf:"varint,15,opt,name=original_purchaser_id" json:"original_purchaser_id,omitempty"` + FantasyTeamCount *uint32 `protobuf:"varint,16,opt,name=fantasy_team_count" json:"fantasy_team_count,omitempty"` + FantasyTeamexpiration *uint32 `protobuf:"varint,17,opt,name=fantasy_teamexpiration" json:"fantasy_teamexpiration,omitempty"` + FantasyTeamsWillLockAt *uint32 `protobuf:"varint,18,opt,name=fantasy_teams_will_lock_at" json:"fantasy_teams_will_lock_at,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPassportDataResponse) Reset() { *m = CMsgPassportDataResponse{} } +func (m *CMsgPassportDataResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgPassportDataResponse) ProtoMessage() {} +func (*CMsgPassportDataResponse) Descriptor() ([]byte, []int) { return dota_client_fantasy_fileDescriptor0, []int{72} } + +const Default_CMsgPassportDataResponse_Result uint32 = 2 + +func (m *CMsgPassportDataResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgPassportDataResponse_Result +} + +func (m *CMsgPassportDataResponse) GetInternational() *CMsgDOTATournament { + if m != nil { + return m.International + } + return nil +} + +func (m *CMsgPassportDataResponse) GetEastQualifiersPredictEndTime() uint32 { + if m != nil && m.EastQualifiersPredictEndTime != nil { + return *m.EastQualifiersPredictEndTime + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetWestQualifiersPredictEndTime() uint32 { + if m != nil && m.WestQualifiersPredictEndTime != nil { + return *m.WestQualifiersPredictEndTime + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetAllstarMatchEndTime() uint32 { + if m != nil && m.AllstarMatchEndTime != nil { + return *m.AllstarMatchEndTime + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetLeagueGuesses() *CMsgDOTAPassportVote { + if m != nil { + return m.LeagueGuesses + } + return nil +} + +func (m *CMsgPassportDataResponse) GetEastQualifiersWinnerTeamId() uint32 { + if m != nil && m.EastQualifiersWinnerTeamId != nil { + return *m.EastQualifiersWinnerTeamId + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetEastQualifiersRunnerUpTeamId() uint32 { + if m != nil && m.EastQualifiersRunnerUpTeamId != nil { + return *m.EastQualifiersRunnerUpTeamId + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetWestQualifiersWinnerTeamId() uint32 { + if m != nil && m.WestQualifiersWinnerTeamId != nil { + return *m.WestQualifiersWinnerTeamId + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetWestQualifiersRunnerUpTeamId() uint32 { + if m != nil && m.WestQualifiersRunnerUpTeamId != nil { + return *m.WestQualifiersRunnerUpTeamId + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetPassportsBought() uint32 { + if m != nil && m.PassportsBought != nil { + return *m.PassportsBought + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetOriginalPurchaserId() uint32 { + if m != nil && m.OriginalPurchaserId != nil { + return *m.OriginalPurchaserId + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetFantasyTeamCount() uint32 { + if m != nil && m.FantasyTeamCount != nil { + return *m.FantasyTeamCount + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetFantasyTeamexpiration() uint32 { + if m != nil && m.FantasyTeamexpiration != nil { + return *m.FantasyTeamexpiration + } + return 0 +} + +func (m *CMsgPassportDataResponse) GetFantasyTeamsWillLockAt() uint32 { + if m != nil && m.FantasyTeamsWillLockAt != nil { + return *m.FantasyTeamsWillLockAt + } + return 0 +} + +func init() { + proto.RegisterType((*CMsgGCPlayerInfo)(nil), "CMsgGCPlayerInfo") + proto.RegisterType((*CMsgGCPlayerInfo_PlayerInfo)(nil), "CMsgGCPlayerInfo.PlayerInfo") + proto.RegisterType((*CMsgGCPlayerInfo_RegionLeaderboard)(nil), "CMsgGCPlayerInfo.RegionLeaderboard") + proto.RegisterType((*CMsgDOTACreateFantasyLeagueRequest)(nil), "CMsgDOTACreateFantasyLeagueRequest") + proto.RegisterType((*CMsgDOTACreateFantasyLeagueResponse)(nil), "CMsgDOTACreateFantasyLeagueResponse") + proto.RegisterType((*CMsgFantasyLeagueScoring)(nil), "CMsgFantasyLeagueScoring") + proto.RegisterType((*CMsgDOTAFantasyLeagueInfo)(nil), "CMsgDOTAFantasyLeagueInfo") + proto.RegisterType((*CMsgDOTAFantasyLeagueInfo_OwnerInfo)(nil), "CMsgDOTAFantasyLeagueInfo.OwnerInfo") + proto.RegisterType((*CMsgDOTAFantasyLeagueEditInfoRequest)(nil), "CMsgDOTAFantasyLeagueEditInfoRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueEditInfoResponse)(nil), "CMsgDOTAFantasyLeagueEditInfoResponse") + proto.RegisterType((*CMsgDOTAFantasyLeagueFindRequest)(nil), "CMsgDOTAFantasyLeagueFindRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueFindResponse)(nil), "CMsgDOTAFantasyLeagueFindResponse") + proto.RegisterType((*CMsgDOTAFantasyLeagueInfoRequest)(nil), "CMsgDOTAFantasyLeagueInfoRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueInfoResponse)(nil), "CMsgDOTAFantasyLeagueInfoResponse") + proto.RegisterType((*CMsgDOTAFantasyLeagueMatchupsRequest)(nil), "CMsgDOTAFantasyLeagueMatchupsRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueMatchupsResponse)(nil), "CMsgDOTAFantasyLeagueMatchupsResponse") + proto.RegisterType((*CMsgDOTAFantasyLeagueMatchupsResponse_Matchup)(nil), "CMsgDOTAFantasyLeagueMatchupsResponse.Matchup") + proto.RegisterType((*CMsgDOTAFantasyLeagueMatchupsResponse_WeeklyMatchups)(nil), "CMsgDOTAFantasyLeagueMatchupsResponse.WeeklyMatchups") + proto.RegisterType((*CMsgDOTAEditFantasyTeamRequest)(nil), "CMsgDOTAEditFantasyTeamRequest") + proto.RegisterType((*CMsgDOTAEditFantasyTeamResponse)(nil), "CMsgDOTAEditFantasyTeamResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID)(nil), "CMsgDOTAFantasyTeamInfoRequestByFantasyLeagueID") + proto.RegisterType((*CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID)(nil), "CMsgDOTAFantasyTeamInfoRequestByOwnerAccountID") + proto.RegisterType((*CMsgDOTAFantasyTeamInfoResponse)(nil), "CMsgDOTAFantasyTeamInfoResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamInfo)(nil), "CMsgDOTAFantasyTeamInfo") + proto.RegisterType((*CMsgDOTAFantasyTeamScoreRequest)(nil), "CMsgDOTAFantasyTeamScoreRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamScoreResponse)(nil), "CMsgDOTAFantasyTeamScoreResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamScoreResponse_CMsgPlayerScore)(nil), "CMsgDOTAFantasyTeamScoreResponse.CMsgPlayerScore") + proto.RegisterType((*CMsgDOTAFantasyTeamStandingsRequest)(nil), "CMsgDOTAFantasyTeamStandingsRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamStandingsResponse)(nil), "CMsgDOTAFantasyTeamStandingsResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamStandingsResponse_CMsgTeamScore)(nil), "CMsgDOTAFantasyTeamStandingsResponse.CMsgTeamScore") + proto.RegisterType((*CMsgDOTAFantasyPlayerScoreRequest)(nil), "CMsgDOTAFantasyPlayerScoreRequest") + proto.RegisterType((*CMsgDOTAFantasyPlayerScoreResponse)(nil), "CMsgDOTAFantasyPlayerScoreResponse") + proto.RegisterType((*CMsgDOTAFantasyPlayerStandingsRequest)(nil), "CMsgDOTAFantasyPlayerStandingsRequest") + proto.RegisterType((*CMsgDOTAFantasyPlayerStandingsResponse)(nil), "CMsgDOTAFantasyPlayerStandingsResponse") + proto.RegisterType((*CMsgDOTAFantasyPlayerStandingsResponse_CMsgPlayerScore)(nil), "CMsgDOTAFantasyPlayerStandingsResponse.CMsgPlayerScore") + proto.RegisterType((*CMsgDOTAFantasyPlayerInfoRequest)(nil), "CMsgDOTAFantasyPlayerInfoRequest") + proto.RegisterType((*CMsgDOTAFantasyPlayerInfoResponse)(nil), "CMsgDOTAFantasyPlayerInfoResponse") + proto.RegisterType((*CMsgDOTAFantasyLeagueCreateRequest)(nil), "CMsgDOTAFantasyLeagueCreateRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueCreateResponse)(nil), "CMsgDOTAFantasyLeagueCreateResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamCreateRequest)(nil), "CMsgDOTAFantasyTeamCreateRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamCreateResponse)(nil), "CMsgDOTAFantasyTeamCreateResponse") + proto.RegisterType((*CMsgDOTAFantasyLeagueEditInvitesRequest)(nil), "CMsgDOTAFantasyLeagueEditInvitesRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueEditInvitesRequest_InviteChange)(nil), "CMsgDOTAFantasyLeagueEditInvitesRequest.InviteChange") + proto.RegisterType((*CMsgDOTAFantasyLeagueEditInvitesResponse)(nil), "CMsgDOTAFantasyLeagueEditInvitesResponse") + proto.RegisterType((*CMsgDOTAFantasyLeagueDraftStatusRequest)(nil), "CMsgDOTAFantasyLeagueDraftStatusRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueDraftStatus)(nil), "CMsgDOTAFantasyLeagueDraftStatus") + proto.RegisterType((*CMsgDOTAFantasyLeagueDraftPlayerRequest)(nil), "CMsgDOTAFantasyLeagueDraftPlayerRequest") + proto.RegisterType((*CMsgDOTAFantasyLeagueDraftPlayerResponse)(nil), "CMsgDOTAFantasyLeagueDraftPlayerResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamRosterSwapRequest)(nil), "CMsgDOTAFantasyTeamRosterSwapRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamRosterSwapResponse)(nil), "CMsgDOTAFantasyTeamRosterSwapResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamRosterAddDropRequest)(nil), "CMsgDOTAFantasyTeamRosterAddDropRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamRosterAddDropResponse)(nil), "CMsgDOTAFantasyTeamRosterAddDropResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamTradesRequest)(nil), "CMsgDOTAFantasyTeamTradesRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamTradesResponse)(nil), "CMsgDOTAFantasyTeamTradesResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamTradesResponse_Trade)(nil), "CMsgDOTAFantasyTeamTradesResponse.Trade") + proto.RegisterType((*CMsgDOTAFantasyTeamTradeCancelRequest)(nil), "CMsgDOTAFantasyTeamTradeCancelRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamTradeCancelResponse)(nil), "CMsgDOTAFantasyTeamTradeCancelResponse") + proto.RegisterType((*CMsgDOTAFantasyTeamRosterRequest)(nil), "CMsgDOTAFantasyTeamRosterRequest") + proto.RegisterType((*CMsgDOTAFantasyTeamRosterResponse)(nil), "CMsgDOTAFantasyTeamRosterResponse") + proto.RegisterType((*CMsgDOTAFantasyPlayerHisoricalStatsRequest)(nil), "CMsgDOTAFantasyPlayerHisoricalStatsRequest") + proto.RegisterType((*CMsgDOTAFantasyPlayerHisoricalStatsResponse)(nil), "CMsgDOTAFantasyPlayerHisoricalStatsResponse") + proto.RegisterType((*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerScoreAccumulator)(nil), "CMsgDOTAFantasyPlayerHisoricalStatsResponse.PlayerScoreAccumulator") + proto.RegisterType((*CMsgDOTAFantasyPlayerHisoricalStatsResponse_PlayerStats)(nil), "CMsgDOTAFantasyPlayerHisoricalStatsResponse.PlayerStats") + proto.RegisterType((*CMsgDOTAFantasyMessageAdd)(nil), "CMsgDOTAFantasyMessageAdd") + proto.RegisterType((*CMsgDOTAFantasyMessagesRequest)(nil), "CMsgDOTAFantasyMessagesRequest") + proto.RegisterType((*CMsgDOTAFantasyMessagesResponse)(nil), "CMsgDOTAFantasyMessagesResponse") + proto.RegisterType((*CMsgDOTAFantasyMessagesResponse_Message)(nil), "CMsgDOTAFantasyMessagesResponse.Message") + proto.RegisterType((*CMsgDOTAFantasyRemoveOwner)(nil), "CMsgDOTAFantasyRemoveOwner") + proto.RegisterType((*CMsgDOTAFantasyRemoveOwnerResponse)(nil), "CMsgDOTAFantasyRemoveOwnerResponse") + proto.RegisterType((*CMsgDOTAFantasyScheduledMatchesRequest)(nil), "CMsgDOTAFantasyScheduledMatchesRequest") + proto.RegisterType((*CMsgDOTAFantasyScheduledMatchesResponse)(nil), "CMsgDOTAFantasyScheduledMatchesResponse") + proto.RegisterType((*CMsgDOTAFantasyScheduledMatchesResponse_ScheduledMatchDays)(nil), "CMsgDOTAFantasyScheduledMatchesResponse.ScheduledMatchDays") + proto.RegisterType((*CMsgDOTAFantasyLeaveLeagueRequest)(nil), "CMsgDOTAFantasyLeaveLeagueRequest") + proto.RegisterType((*CMsgDOTAFantasyLeaveLeagueResponse)(nil), "CMsgDOTAFantasyLeaveLeagueResponse") + proto.RegisterType((*CMsgDOTAFantasyPlayerScoreDetailsRequest)(nil), "CMsgDOTAFantasyPlayerScoreDetailsRequest") + proto.RegisterType((*CMsgDOTAFantasyPlayerScoreDetailsResponse)(nil), "CMsgDOTAFantasyPlayerScoreDetailsResponse") + proto.RegisterType((*CMsgDOTAFantasyPlayerScoreDetailsResponse_PlayerMatchData)(nil), "CMsgDOTAFantasyPlayerScoreDetailsResponse.PlayerMatchData") + proto.RegisterType((*CMsgDOTATournament)(nil), "CMsgDOTATournament") + proto.RegisterType((*CMsgDOTATournament_Team)(nil), "CMsgDOTATournament.Team") + proto.RegisterType((*CMsgDOTATournament_Game)(nil), "CMsgDOTATournament.Game") + proto.RegisterType((*CMsgDOTATournament_Node)(nil), "CMsgDOTATournament.Node") + proto.RegisterType((*CMsgDOTATournamentRequest)(nil), "CMsgDOTATournamentRequest") + proto.RegisterType((*CMsgDOTATournamentResponse)(nil), "CMsgDOTATournamentResponse") + proto.RegisterType((*CMsgDOTAClearTournamentGame)(nil), "CMsgDOTAClearTournamentGame") + proto.RegisterType((*CMsgDOTAPassportVoteTeamGuess)(nil), "CMsgDOTAPassportVoteTeamGuess") + proto.RegisterType((*CMsgDOTAPassportVoteGenericSelection)(nil), "CMsgDOTAPassportVoteGenericSelection") + proto.RegisterType((*CMsgDOTAPassportStampedPlayer)(nil), "CMsgDOTAPassportStampedPlayer") + proto.RegisterType((*CMsgDOTAPassportPlayerCardChallenge)(nil), "CMsgDOTAPassportPlayerCardChallenge") + proto.RegisterType((*CMsgDOTAPassportVote)(nil), "CMsgDOTAPassportVote") + proto.RegisterType((*CMsgPassportDataRequest)(nil), "CMsgPassportDataRequest") + proto.RegisterType((*CMsgPassportDataResponse)(nil), "CMsgPassportDataResponse") + proto.RegisterEnum("ETournamentGameState", ETournamentGameState_name, ETournamentGameState_value) + proto.RegisterEnum("ETournamentTeamState", ETournamentTeamState_name, ETournamentTeamState_value) + proto.RegisterEnum("ETournamentState", ETournamentState_name, ETournamentState_value) + proto.RegisterEnum("ETournamentNodeState", ETournamentNodeState_name, ETournamentNodeState_value) + proto.RegisterEnum("DOTA_2013PassportSelectionIndices", DOTA_2013PassportSelectionIndices_name, DOTA_2013PassportSelectionIndices_value) + proto.RegisterEnum("CMsgDOTACreateFantasyLeagueResponse_EResult", CMsgDOTACreateFantasyLeagueResponse_EResult_name, CMsgDOTACreateFantasyLeagueResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeagueEditInfoResponse_EResult", CMsgDOTAFantasyLeagueEditInfoResponse_EResult_name, CMsgDOTAFantasyLeagueEditInfoResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeagueFindResponse_EResult", CMsgDOTAFantasyLeagueFindResponse_EResult_name, CMsgDOTAFantasyLeagueFindResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeagueInfoResponse_EResult", CMsgDOTAFantasyLeagueInfoResponse_EResult_name, CMsgDOTAFantasyLeagueInfoResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeagueMatchupsResponse_EResult", CMsgDOTAFantasyLeagueMatchupsResponse_EResult_name, CMsgDOTAFantasyLeagueMatchupsResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAEditFantasyTeamResponse_EResult", CMsgDOTAEditFantasyTeamResponse_EResult_name, CMsgDOTAEditFantasyTeamResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamScoreResponse_EResult", CMsgDOTAFantasyTeamScoreResponse_EResult_name, CMsgDOTAFantasyTeamScoreResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamStandingsResponse_EResult", CMsgDOTAFantasyTeamStandingsResponse_EResult_name, CMsgDOTAFantasyTeamStandingsResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyPlayerScoreResponse_EResult", CMsgDOTAFantasyPlayerScoreResponse_EResult_name, CMsgDOTAFantasyPlayerScoreResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyPlayerStandingsResponse_EResult", CMsgDOTAFantasyPlayerStandingsResponse_EResult_name, CMsgDOTAFantasyPlayerStandingsResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeagueCreateResponse_EResult", CMsgDOTAFantasyLeagueCreateResponse_EResult_name, CMsgDOTAFantasyLeagueCreateResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamCreateResponse_EResult", CMsgDOTAFantasyTeamCreateResponse_EResult_name, CMsgDOTAFantasyTeamCreateResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeagueEditInvitesResponse_EResult", CMsgDOTAFantasyLeagueEditInvitesResponse_EResult_name, CMsgDOTAFantasyLeagueEditInvitesResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult", CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult_name, CMsgDOTAFantasyLeagueDraftPlayerResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamRosterSwapResponse_EResult", CMsgDOTAFantasyTeamRosterSwapResponse_EResult_name, CMsgDOTAFantasyTeamRosterSwapResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamRosterAddDropResponse_EResult", CMsgDOTAFantasyTeamRosterAddDropResponse_EResult_name, CMsgDOTAFantasyTeamRosterAddDropResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamTradesResponse_EResult", CMsgDOTAFantasyTeamTradesResponse_EResult_name, CMsgDOTAFantasyTeamTradesResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamTradeCancelResponse_EResult", CMsgDOTAFantasyTeamTradeCancelResponse_EResult_name, CMsgDOTAFantasyTeamTradeCancelResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyTeamRosterResponse_EResult", CMsgDOTAFantasyTeamRosterResponse_EResult_name, CMsgDOTAFantasyTeamRosterResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult", CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult_name, CMsgDOTAFantasyPlayerHisoricalStatsResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyMessagesResponse_EResult", CMsgDOTAFantasyMessagesResponse_EResult_name, CMsgDOTAFantasyMessagesResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyRemoveOwnerResponse_EResult", CMsgDOTAFantasyRemoveOwnerResponse_EResult_name, CMsgDOTAFantasyRemoveOwnerResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyScheduledMatchesResponse_EResult", CMsgDOTAFantasyScheduledMatchesResponse_EResult_name, CMsgDOTAFantasyScheduledMatchesResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyLeaveLeagueResponse_EResult", CMsgDOTAFantasyLeaveLeagueResponse_EResult_name, CMsgDOTAFantasyLeaveLeagueResponse_EResult_value) + proto.RegisterEnum("CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult", CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult_name, CMsgDOTAFantasyPlayerScoreDetailsResponse_EResult_value) +} + +var dota_client_fantasy_fileDescriptor0 = []byte{ + // 5420 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x3b, 0x4b, 0x70, 0x1b, 0xc9, + 0x75, 0xc6, 0x8f, 0x9f, 0xe6, 0xaf, 0x05, 0xfd, 0x20, 0xe8, 0xb3, 0xd2, 0x48, 0xbb, 0x2b, 0x71, + 0xbd, 0x58, 0x02, 0x24, 0x45, 0x4a, 0x6b, 0xc7, 0x81, 0x00, 0x90, 0xcb, 0x5d, 0x12, 0xe0, 0x12, + 0xa0, 0x64, 0x6d, 0x3e, 0x53, 0x43, 0x60, 0x04, 0x4e, 0x09, 0xc0, 0x60, 0x31, 0x03, 0x72, 0x95, + 0x4a, 0xa5, 0xbc, 0x2e, 0x27, 0x95, 0x4d, 0xf9, 0x90, 0x1c, 0xed, 0x38, 0xd9, 0xc4, 0x5e, 0x3b, + 0x49, 0xa5, 0x2a, 0xe5, 0xaa, 0xe4, 0x90, 0x6b, 0xaa, 0x52, 0xf6, 0x29, 0xb6, 0x4f, 0xa9, 0xe4, + 0x90, 0x93, 0x0f, 0xc9, 0x25, 0xa9, 0xa4, 0x72, 0x4f, 0xe5, 0xf5, 0x67, 0xfe, 0xd3, 0xc3, 0xa1, + 0x96, 0xf6, 0x89, 0x44, 0xbf, 0xd7, 0x3d, 0xdd, 0xef, 0xff, 0x5e, 0xbf, 0x46, 0x77, 0x3a, 0xba, + 0xa9, 0xc8, 0xdd, 0x76, 0x5f, 0x35, 0x0c, 0xa5, 0xab, 0x1a, 0x72, 0xbb, 0xa7, 0xa9, 0x03, 0x53, + 0x7e, 0xa6, 0x0c, 0x4c, 0xc5, 0x78, 0x51, 0x18, 0x8e, 0x74, 0x53, 0xcf, 0x5f, 0x0b, 0x60, 0xe9, + 0xfd, 0xbe, 0x3e, 0x60, 0x50, 0xe9, 0x1b, 0x29, 0x84, 0x2b, 0x3b, 0x46, 0x77, 0xb3, 0xb2, 0xdb, + 0x53, 0x5e, 0xa8, 0xa3, 0xad, 0xc1, 0x33, 0x3d, 0x5b, 0x42, 0xb3, 0x43, 0xfa, 0x4b, 0xd6, 0xe0, + 0xa7, 0x91, 0x4b, 0xdc, 0x4c, 0xdd, 0x9d, 0x29, 0x5d, 0x2b, 0xf8, 0x11, 0x0b, 0xae, 0x39, 0x0f, + 0xd0, 0x6c, 0x4f, 0x55, 0x3a, 0xea, 0xe8, 0x40, 0x57, 0x46, 0x1d, 0x23, 0x97, 0xa4, 0x73, 0x6e, + 0x07, 0xe7, 0xec, 0xa9, 0x5d, 0x4d, 0x1f, 0x6c, 0x3b, 0xb8, 0xf9, 0x7f, 0x4c, 0x20, 0xe4, 0x5a, + 0x29, 0x8b, 0x90, 0xd2, 0x6e, 0xeb, 0x63, 0x38, 0x89, 0xd6, 0x81, 0x6f, 0x27, 0xee, 0xce, 0x65, + 0x67, 0x51, 0x7a, 0xa0, 0xf4, 0x55, 0x58, 0x35, 0x71, 0x77, 0x3a, 0x7b, 0x01, 0xcd, 0x52, 0xf8, + 0xe8, 0x05, 0x1c, 0xa6, 0xa3, 0xe6, 0x52, 0xd6, 0x28, 0x3f, 0xb9, 0x3c, 0xd2, 0x7b, 0x6a, 0x2e, + 0x4d, 0x67, 0x2e, 0xa0, 0x49, 0x53, 0x55, 0xfa, 0x64, 0xa9, 0x0c, 0x1d, 0x38, 0x87, 0xa6, 0xe9, + 0x00, 0x5d, 0x6f, 0x82, 0xce, 0xc4, 0x68, 0x8a, 0x0e, 0x99, 0x4a, 0x37, 0x37, 0x49, 0x47, 0x60, + 0x96, 0x31, 0xd4, 0x07, 0x86, 0x3e, 0xca, 0x4d, 0xd1, 0x01, 0x98, 0xa5, 0x19, 0x72, 0x4f, 0x6f, + 0x3f, 0x57, 0x3b, 0xb9, 0x69, 0x18, 0x9a, 0xca, 0xce, 0xa3, 0x09, 0x18, 0x02, 0x32, 0xe6, 0x10, + 0xf9, 0x9d, 0x7f, 0x88, 0xce, 0x05, 0xce, 0x46, 0x96, 0xee, 0x68, 0x47, 0x9a, 0x01, 0xc3, 0xfc, + 0x28, 0xe7, 0xd1, 0x8c, 0x73, 0x3c, 0x46, 0xa7, 0x39, 0xe9, 0x6f, 0x12, 0x48, 0x22, 0x94, 0xaa, + 0x36, 0x5a, 0xe5, 0xca, 0x48, 0x55, 0x4c, 0x75, 0x83, 0x1d, 0x05, 0xd6, 0xea, 0x8e, 0xd5, 0x3d, + 0xf5, 0xc3, 0xb1, 0x6a, 0x98, 0x64, 0x6e, 0x8f, 0x0e, 0xb0, 0xdd, 0x27, 0xe8, 0xd6, 0x9c, 0xc1, + 0x9e, 0xde, 0xd5, 0x29, 0x89, 0xd2, 0xd9, 0x77, 0xd1, 0xbc, 0xa1, 0xf6, 0xd4, 0xb6, 0x09, 0x1f, + 0x96, 0xfb, 0x16, 0x91, 0xe6, 0x4b, 0x97, 0x0b, 0x7c, 0x61, 0xb9, 0x69, 0x83, 0x77, 0x00, 0xfc, + 0xf0, 0xca, 0x46, 0xb9, 0xde, 0x2a, 0x37, 0x9f, 0xca, 0xcd, 0xda, 0x76, 0xad, 0xd2, 0xda, 0x6a, + 0xd4, 0xe5, 0xad, 0xfa, 0xe3, 0xf2, 0xf6, 0x56, 0x95, 0x30, 0x84, 0x92, 0x87, 0x6e, 0x9a, 0x91, + 0x55, 0xfa, 0xdf, 0x04, 0xba, 0x1d, 0xb9, 0x61, 0x4a, 0x3e, 0x35, 0x5b, 0x43, 0x13, 0x23, 0xd5, + 0x18, 0xf7, 0x4c, 0xba, 0xd9, 0xf9, 0xd2, 0x17, 0x0b, 0x31, 0x66, 0x15, 0x6a, 0x7b, 0x74, 0xce, + 0xc3, 0xc9, 0xe6, 0x7e, 0xa5, 0x52, 0x6b, 0x36, 0xa5, 0x6f, 0x24, 0xd0, 0x24, 0x1f, 0xcc, 0xce, + 0x20, 0x6b, 0x18, 0x7f, 0x21, 0x7b, 0x11, 0x9d, 0xab, 0xed, 0xed, 0x35, 0xf6, 0xe4, 0xfd, 0x7a, + 0x73, 0xb7, 0x56, 0xd9, 0xda, 0xd8, 0xaa, 0x55, 0x71, 0x22, 0x9b, 0x47, 0x97, 0xd8, 0x70, 0xab, + 0xd1, 0x90, 0x77, 0xca, 0xf5, 0xa7, 0xf2, 0x76, 0xad, 0xbc, 0xb9, 0x5f, 0x6b, 0xe2, 0x64, 0xf6, + 0x1a, 0xca, 0x31, 0x18, 0x3f, 0x9f, 0xdc, 0xaa, 0x95, 0x77, 0xe4, 0x4a, 0x63, 0xbf, 0xde, 0xc2, + 0xa9, 0xec, 0x55, 0x74, 0x99, 0x41, 0x2b, 0x7b, 0xb5, 0x32, 0x25, 0x43, 0x75, 0xab, 0x59, 0x7e, + 0xb4, 0x0d, 0xcb, 0xa6, 0xa5, 0x4f, 0x93, 0x28, 0x47, 0xf6, 0xef, 0xd9, 0x75, 0xb3, 0xad, 0x8f, + 0xb4, 0x41, 0x37, 0x3b, 0x87, 0x32, 0x3d, 0xf5, 0x48, 0xed, 0xd1, 0x93, 0x26, 0xc9, 0xcf, 0xe7, + 0x5a, 0xaf, 0x67, 0x50, 0x86, 0x24, 0x89, 0xb4, 0x74, 0xe0, 0xc0, 0x87, 0x06, 0x65, 0x44, 0x92, + 0x48, 0x98, 0x62, 0x18, 0x9a, 0x61, 0x1a, 0x94, 0xa2, 0x49, 0x22, 0x61, 0x3d, 0xc5, 0x30, 0xe5, + 0x43, 0x0d, 0x86, 0x32, 0xce, 0x9c, 0x81, 0xa6, 0x1a, 0x54, 0x4e, 0x93, 0x70, 0xf2, 0x54, 0x77, + 0xd8, 0xa7, 0x22, 0x9a, 0x24, 0x2a, 0xf1, 0xd1, 0x10, 0x7e, 0x4d, 0x59, 0x5f, 0x33, 0xcc, 0xf1, + 0xc0, 0xa0, 0xb2, 0x49, 0x57, 0x3f, 0x54, 0x95, 0x1e, 0x6c, 0x8b, 0x0a, 0x67, 0x92, 0x08, 0x89, + 0xa9, 0x1f, 0x83, 0x46, 0xb3, 0x3d, 0xcd, 0xd0, 0x41, 0xd0, 0x98, 0x91, 0x6e, 0x1c, 0x2a, 0x03, + 0x3e, 0x3a, 0x4b, 0x47, 0xf3, 0x28, 0xdb, 0x07, 0x3a, 0x6b, 0x43, 0xb0, 0x26, 0x23, 0x90, 0x6f, + 0xb5, 0xaf, 0x8d, 0xfb, 0xb9, 0x39, 0x0a, 0x7b, 0x05, 0x5d, 0xf6, 0xc0, 0xf4, 0x67, 0x60, 0x55, + 0x40, 0x86, 0x94, 0x5e, 0x6e, 0x9e, 0x20, 0x48, 0x3f, 0xc9, 0xa0, 0x2b, 0x16, 0x87, 0x3d, 0x54, + 0xa2, 0xaa, 0x7d, 0x05, 0x9d, 0xb3, 0x54, 0x94, 0x8b, 0xac, 0xad, 0xe1, 0xb0, 0x32, 0x31, 0x4c, + 0x1a, 0x5d, 0x0e, 0xd6, 0x76, 0x99, 0x80, 0x24, 0x45, 0xb8, 0x8a, 0xce, 0xfb, 0xe6, 0x52, 0x1d, + 0x60, 0xba, 0x1f, 0x14, 0xf7, 0xf4, 0x19, 0x89, 0x7b, 0xc6, 0xb2, 0x3f, 0x54, 0xb9, 0x26, 0xa8, + 0x72, 0x2d, 0x82, 0x75, 0x60, 0x4c, 0xa7, 0xbc, 0x98, 0x29, 0x5d, 0x29, 0x08, 0xa5, 0x02, 0x56, + 0xeb, 0x8c, 0x94, 0x67, 0xa6, 0x6c, 0x6a, 0xb0, 0xdb, 0x59, 0xba, 0xda, 0x65, 0xb4, 0xc0, 0xc6, + 0x86, 0x5a, 0xfb, 0x39, 0x03, 0xcc, 0x51, 0x00, 0x30, 0xc4, 0x50, 0x15, 0x03, 0x36, 0x69, 0x98, + 0xca, 0xc8, 0xcc, 0x2d, 0xd0, 0xd1, 0x8b, 0x68, 0x8e, 0x8f, 0xf6, 0xd4, 0x41, 0xd7, 0x3c, 0xcc, + 0x61, 0x3a, 0x0c, 0x2b, 0x1f, 0xa9, 0xa6, 0x2e, 0x1f, 0xe9, 0x26, 0x48, 0xc8, 0x39, 0x6b, 0x01, + 0xa5, 0xfd, 0xe1, 0x18, 0xec, 0x0d, 0x39, 0xaa, 0x91, 0xcb, 0xd2, 0x51, 0x90, 0x23, 0xa3, 0xa7, + 0x9b, 0x72, 0x31, 0x77, 0xde, 0xf3, 0xbb, 0x94, 0xbb, 0xe0, 0xf9, 0xbd, 0x9c, 0xbb, 0xe8, 0xf9, + 0xbd, 0x92, 0xbb, 0xe4, 0xf9, 0xbd, 0x9a, 0xbb, 0x6c, 0x99, 0xb0, 0x03, 0x75, 0xd0, 0x3e, 0x94, + 0xc9, 0xa8, 0x91, 0xcb, 0xd1, 0xc1, 0x75, 0x84, 0xf4, 0xe3, 0x01, 0xf7, 0x19, 0xb9, 0x2b, 0xd4, + 0xfc, 0xdf, 0x29, 0x08, 0x65, 0xa1, 0xd0, 0x20, 0xc8, 0x54, 0x2a, 0x40, 0x58, 0x99, 0xbb, 0x31, + 0x72, 0x79, 0x62, 0x0d, 0xa9, 0x89, 0x06, 0xa2, 0xc8, 0xbf, 0x05, 0x92, 0x90, 0xbb, 0x6a, 0x6f, + 0x81, 0xd2, 0x20, 0x77, 0x8d, 0xfe, 0x06, 0xbb, 0x3a, 0x04, 0xfd, 0x39, 0xd6, 0x47, 0x9d, 0xdc, + 0x75, 0x22, 0x02, 0xf9, 0x7d, 0x34, 0xed, 0x2c, 0x99, 0x43, 0x98, 0x6d, 0x26, 0xe0, 0x49, 0xa8, + 0xb5, 0x04, 0xd2, 0x33, 0x19, 0xa2, 0xb2, 0x35, 0x45, 0xe4, 0x92, 0x3b, 0x3c, 0x17, 0x7e, 0x8a, + 0x5a, 0xe6, 0x21, 0xba, 0x13, 0x7a, 0x86, 0x5a, 0x47, 0x33, 0xc9, 0xa7, 0x2c, 0xd3, 0x1c, 0x21, + 0xda, 0x6f, 0xa2, 0x69, 0x15, 0xb0, 0x19, 0x61, 0x92, 0x54, 0x60, 0xf2, 0x62, 0xc2, 0x48, 0x7f, + 0x9f, 0x40, 0xaf, 0x9e, 0xf0, 0x49, 0x6e, 0x5c, 0x37, 0x7d, 0xc6, 0xb5, 0x50, 0x88, 0x35, 0x2f, + 0x68, 0x5e, 0x37, 0x4e, 0x67, 0x5d, 0x2f, 0xa3, 0xf3, 0x6c, 0xb8, 0xde, 0x90, 0x77, 0x6b, 0x7b, + 0x3b, 0x5b, 0xcd, 0x26, 0x28, 0x10, 0x4e, 0x4a, 0x0d, 0x74, 0x33, 0x74, 0x07, 0x1b, 0xda, 0xa0, + 0x13, 0x83, 0x50, 0x6e, 0xa6, 0x52, 0x4f, 0x2f, 0xfd, 0x38, 0x89, 0x6e, 0x45, 0xac, 0xc8, 0xe9, + 0x50, 0xf1, 0xd1, 0x61, 0xb1, 0x70, 0xe2, 0x9c, 0x00, 0x0d, 0x44, 0xf6, 0x85, 0x45, 0x1c, 0xb0, + 0x69, 0x8f, 0x75, 0x72, 0x4c, 0x8f, 0xf4, 0x99, 0xc8, 0x35, 0xd9, 0x3e, 0x88, 0xb9, 0x1e, 0x20, + 0x56, 0x4b, 0xde, 0x00, 0x2f, 0x43, 0x28, 0x78, 0x09, 0x65, 0x19, 0xec, 0x51, 0xb9, 0x2a, 0xef, + 0x96, 0x9b, 0xcd, 0x27, 0x8d, 0xbd, 0x2a, 0xf8, 0xa6, 0x50, 0x82, 0xa7, 0x40, 0xfa, 0x11, 0x1b, + 0xde, 0xd8, 0xdf, 0xde, 0xc6, 0x69, 0x10, 0xef, 0x0b, 0xec, 0x77, 0x79, 0x1b, 0xbc, 0x54, 0xf5, + 0xa9, 0xbc, 0x53, 0xdb, 0x79, 0x54, 0xdb, 0xc3, 0x19, 0x87, 0x35, 0xfc, 0xa3, 0xdb, 0x8d, 0xca, + 0x7b, 0xb0, 0xc4, 0x84, 0xf4, 0x65, 0x01, 0x6b, 0xe2, 0xc9, 0xb0, 0xf4, 0xc3, 0x84, 0x80, 0x11, + 0x1e, 0x81, 0x8c, 0xc9, 0x88, 0x5f, 0x8c, 0x30, 0x12, 0x52, 0xf2, 0x53, 0x6f, 0x01, 0x2d, 0xa5, + 0xb2, 0x40, 0x73, 0x77, 0x14, 0xb3, 0x7d, 0x38, 0x1e, 0x1a, 0x31, 0x4e, 0xfd, 0xed, 0xb4, 0x40, + 0x15, 0x9d, 0x35, 0x4e, 0xa7, 0x8a, 0xfe, 0x79, 0x41, 0x31, 0x0c, 0xdd, 0x0d, 0xf3, 0x80, 0x75, + 0xb4, 0x70, 0xac, 0xaa, 0xcf, 0x7b, 0x2f, 0xe4, 0x3e, 0x5f, 0x86, 0xda, 0xa8, 0x99, 0xd2, 0x6a, + 0xcc, 0x8f, 0x3d, 0xa1, 0xb3, 0xad, 0xe1, 0x7c, 0x1b, 0x4d, 0xf2, 0xff, 0x89, 0xcf, 0xf7, 0xdb, + 0x4b, 0xf0, 0x16, 0x4c, 0x2b, 0xc3, 0x60, 0x25, 0xbe, 0xa5, 0x05, 0xe6, 0x09, 0x55, 0x40, 0xb6, + 0xc3, 0x1a, 0x36, 0x50, 0x62, 0x61, 0x4d, 0xfe, 0x18, 0xcd, 0x7b, 0x3f, 0x9b, 0xfd, 0x0a, 0x9a, + 0xe4, 0xfb, 0xe7, 0x89, 0x45, 0x5c, 0x5a, 0x59, 0x9b, 0x05, 0xc7, 0x47, 0xdd, 0x23, 0xf3, 0x9c, + 0x49, 0xcb, 0x74, 0xa8, 0x83, 0x0e, 0x1b, 0x49, 0x51, 0xde, 0xc9, 0x67, 0x23, 0x46, 0x22, 0x63, + 0x97, 0x92, 0xc6, 0xe8, 0x86, 0xb5, 0x6f, 0x62, 0x61, 0xf9, 0xde, 0x5b, 0x10, 0x3a, 0xc4, 0x30, + 0x75, 0x56, 0x90, 0x01, 0x26, 0x49, 0xfd, 0x88, 0x9f, 0xc1, 0x93, 0x99, 0xa4, 0xac, 0xb4, 0x83, + 0x0e, 0xd1, 0xe0, 0x83, 0x10, 0x34, 0x2d, 0xfd, 0x47, 0x02, 0xbd, 0x22, 0xfc, 0x2e, 0x97, 0xc6, + 0xb2, 0x4f, 0x1a, 0xef, 0x16, 0x4e, 0x98, 0x11, 0xd4, 0xc2, 0x8f, 0x4f, 0x19, 0x71, 0xdb, 0x71, + 0xb3, 0x27, 0xaa, 0xde, 0xaa, 0x6f, 0x34, 0xdc, 0x21, 0x77, 0xbd, 0xbc, 0x53, 0xb3, 0x8d, 0x56, + 0xab, 0xfc, 0x5e, 0x0d, 0x08, 0x29, 0xa2, 0x70, 0x5a, 0xda, 0x46, 0x6f, 0xf9, 0x24, 0x83, 0xec, + 0xd9, 0x65, 0xb1, 0x1e, 0xbd, 0xf0, 0xda, 0x95, 0x6a, 0x94, 0x32, 0xbf, 0x8b, 0x0a, 0x27, 0xad, + 0x46, 0x03, 0x88, 0x32, 0x13, 0x73, 0x58, 0x4c, 0x18, 0x45, 0xc0, 0xce, 0x5e, 0x11, 0xae, 0xc5, + 0x79, 0x70, 0x0f, 0x4d, 0x32, 0x1e, 0x58, 0xf9, 0x73, 0x4e, 0xf4, 0x79, 0xe9, 0x47, 0x09, 0x74, + 0x59, 0x00, 0x8b, 0x92, 0xa1, 0xb0, 0xed, 0x25, 0x2d, 0x95, 0xb5, 0x26, 0xb9, 0xa4, 0x2c, 0x15, + 0x94, 0xb2, 0x74, 0x50, 0xca, 0x32, 0x34, 0xc4, 0x85, 0x80, 0xf7, 0x58, 0x1b, 0xb0, 0xc4, 0x83, + 0x46, 0x5f, 0x3d, 0xdd, 0x30, 0x20, 0xcc, 0x9c, 0xa4, 0xbf, 0x2f, 0xa1, 0xf9, 0xf6, 0x78, 0x34, + 0x22, 0xc5, 0x06, 0x48, 0x20, 0x4c, 0x95, 0x64, 0xc9, 0x24, 0x58, 0xfa, 0xe7, 0x44, 0x28, 0x5d, + 0x48, 0x2c, 0xac, 0xc6, 0x50, 0x8a, 0x97, 0x3b, 0x10, 0x44, 0xd3, 0xcf, 0xb4, 0x1e, 0x6c, 0x82, + 0x99, 0x45, 0x32, 0x89, 0x6a, 0x0a, 0xfd, 0x12, 0x03, 0xb8, 0xcc, 0x45, 0xc6, 0x37, 0xc7, 0xb6, + 0x1a, 0x13, 0x56, 0xac, 0xad, 0x0d, 0xda, 0xbd, 0x71, 0x47, 0x95, 0x69, 0x88, 0x4b, 0x0f, 0x3c, + 0x25, 0xfd, 0x77, 0x32, 0xe0, 0x3e, 0x5d, 0x07, 0xe3, 0x1c, 0x7f, 0xe4, 0xd3, 0xba, 0x7b, 0x85, + 0x93, 0xa6, 0x04, 0xcd, 0xbf, 0xff, 0xa0, 0xd4, 0x98, 0xf2, 0x14, 0xb2, 0x81, 0x2e, 0x58, 0x30, + 0x1e, 0xad, 0x32, 0x28, 0x73, 0x02, 0xc5, 0x93, 0xbf, 0x46, 0x10, 0x58, 0xa1, 0x85, 0x8e, 0xe7, + 0x57, 0xd0, 0x82, 0x6f, 0x28, 0xb4, 0xf8, 0x42, 0x72, 0x4b, 0x67, 0x1b, 0x92, 0x7a, 0x36, 0xc1, + 0x62, 0xf6, 0x3a, 0xba, 0xc2, 0x00, 0x8d, 0x27, 0xf5, 0xda, 0x1e, 0x0d, 0x8f, 0xb6, 0xea, 0xdc, + 0xf4, 0x82, 0x79, 0xfd, 0xa9, 0xab, 0xc2, 0xe0, 0x3e, 0x91, 0xa9, 0x0c, 0x3a, 0x90, 0x58, 0xc5, + 0x70, 0xdf, 0x64, 0xe3, 0x2c, 0x89, 0x63, 0x42, 0x14, 0x2a, 0x0f, 0x29, 0x91, 0x3c, 0xa4, 0x45, + 0xc2, 0x95, 0xf1, 0x09, 0x17, 0xcd, 0xda, 0x29, 0x94, 0xca, 0xd0, 0x14, 0xd1, 0x0e, 0x0e, 0xd2, + 0x06, 0xf2, 0xa1, 0xd2, 0xeb, 0x71, 0x21, 0xfa, 0x38, 0x1d, 0x88, 0x48, 0x7c, 0x27, 0xe2, 0x82, + 0xb4, 0xe1, 0x13, 0xa4, 0x37, 0x0b, 0x71, 0xa6, 0x05, 0x85, 0xe9, 0x1d, 0x48, 0xfa, 0x6d, 0x21, + 0xb2, 0x82, 0x85, 0xe5, 0x78, 0x8b, 0x11, 0x24, 0x5b, 0x82, 0xf2, 0xff, 0x97, 0x40, 0x73, 0x9e, + 0x91, 0xb3, 0x57, 0x63, 0xd7, 0x82, 0x3e, 0x97, 0x47, 0x84, 0x92, 0x2d, 0x48, 0x6d, 0x56, 0xc6, + 0x8a, 0xc8, 0x3d, 0xe8, 0xae, 0x72, 0x9e, 0x2d, 0xaf, 0xac, 0x50, 0x42, 0xd2, 0x67, 0x1a, 0x92, + 0x28, 0x5d, 0x05, 0x4c, 0x9a, 0xc9, 0x2b, 0x26, 0x96, 0x85, 0x9b, 0xf6, 0x59, 0x38, 0x64, 0xe7, + 0x9b, 0xe6, 0x48, 0x55, 0x9e, 0xd3, 0x52, 0x49, 0xe6, 0xcc, 0x32, 0xa4, 0x7f, 0x08, 0xc6, 0xd1, + 0x2e, 0xf5, 0x8b, 0x21, 0xd3, 0xa1, 0xa9, 0xea, 0x2f, 0x55, 0xbe, 0xa5, 0x6f, 0x26, 0x9d, 0x62, + 0x65, 0xd8, 0x19, 0xb8, 0x14, 0x57, 0x7d, 0x52, 0xfc, 0x46, 0xe1, 0xe4, 0x49, 0xa7, 0x8a, 0x87, + 0x05, 0x59, 0x3b, 0xcf, 0xf2, 0x39, 0xc8, 0xe5, 0xe6, 0x6c, 0xb9, 0xa0, 0xd5, 0xb5, 0x33, 0x63, + 0xe9, 0x8f, 0x83, 0xf9, 0x3a, 0x3f, 0xd9, 0xcb, 0x9b, 0x2a, 0x10, 0x4e, 0x5a, 0xc3, 0x4e, 0x89, + 0x19, 0x9b, 0x16, 0x31, 0x36, 0x23, 0x62, 0xec, 0x84, 0x98, 0xb1, 0xcc, 0x40, 0xfd, 0x6e, 0x0a, + 0xbd, 0x76, 0xd2, 0x49, 0x38, 0x73, 0xdf, 0xf1, 0x31, 0xf7, 0xad, 0x42, 0xbc, 0x89, 0xa7, 0x62, + 0xb0, 0x97, 0x0a, 0x75, 0x34, 0xe7, 0x76, 0x7b, 0xa4, 0x6e, 0x4a, 0xec, 0xd9, 0x5a, 0xdc, 0x2f, + 0xfb, 0xbd, 0xdf, 0x6e, 0xd0, 0xfb, 0x85, 0x4a, 0x54, 0x22, 0x4c, 0xa2, 0x92, 0x5e, 0x89, 0x4a, + 0x9d, 0xa9, 0x44, 0x49, 0x81, 0x60, 0xc3, 0xb9, 0x1e, 0xe1, 0xb2, 0x24, 0x55, 0x04, 0x76, 0xc4, + 0x13, 0x83, 0xde, 0x40, 0xa9, 0xbe, 0xd1, 0xa5, 0x27, 0x98, 0x29, 0x9d, 0x0b, 0xdc, 0xc5, 0x48, + 0x9f, 0x26, 0x02, 0x9a, 0xcc, 0x22, 0x69, 0x56, 0x9c, 0xb7, 0xe4, 0x16, 0xe2, 0x43, 0x5e, 0x80, + 0xb4, 0xc9, 0x11, 0x59, 0x2d, 0x71, 0xd7, 0x71, 0xbc, 0x79, 0x8c, 0x4b, 0x1b, 0xad, 0x92, 0x2a, + 0x33, 0x37, 0xe0, 0x33, 0x4d, 0xad, 0xfd, 0x5c, 0x05, 0x8a, 0x9b, 0x6a, 0xdf, 0x96, 0x56, 0xe9, + 0x67, 0xc9, 0x40, 0x14, 0xe0, 0xdd, 0xe1, 0x89, 0xf7, 0x0c, 0x11, 0xb3, 0x4e, 0x23, 0x8c, 0x24, + 0x48, 0x0f, 0xe7, 0xae, 0x80, 0x8d, 0xbe, 0x94, 0xb2, 0x59, 0x2b, 0x37, 0x49, 0x91, 0x99, 0xa4, + 0x94, 0x57, 0xd0, 0xc5, 0x40, 0xae, 0x49, 0x32, 0x23, 0x77, 0x2e, 0x44, 0x40, 0x34, 0x85, 0xa2, + 0x80, 0x74, 0xb8, 0x0c, 0x65, 0x9c, 0xcc, 0x6a, 0xa3, 0xbc, 0xb5, 0x5d, 0x83, 0xd5, 0x1a, 0x9b, + 0x0d, 0x79, 0x7f, 0x77, 0xbb, 0x51, 0xae, 0xe2, 0x09, 0x10, 0xda, 0x05, 0x7b, 0x6b, 0xad, 0xad, + 0xca, 0x7b, 0xb5, 0x16, 0x9e, 0x94, 0x7e, 0x3f, 0x11, 0x1a, 0xcb, 0x7a, 0x59, 0x7e, 0x9a, 0x2a, + 0x5d, 0x58, 0xe2, 0x6a, 0x71, 0x37, 0x2d, 0xe0, 0x2e, 0xe5, 0xba, 0xf4, 0x87, 0xa9, 0x80, 0x14, + 0xbb, 0xb7, 0x12, 0xb7, 0xaa, 0x14, 0x9c, 0x73, 0x72, 0x60, 0xed, 0x4a, 0xbc, 0xa5, 0x4f, 0x92, + 0xa7, 0x65, 0x6d, 0x14, 0xd9, 0xc9, 0x2d, 0xc9, 0x55, 0x87, 0x89, 0xd6, 0x45, 0x83, 0x53, 0x53, + 0x48, 0x41, 0x40, 0x33, 0xef, 0x20, 0x70, 0x06, 0x7b, 0x6b, 0x7c, 0x19, 0x61, 0x8d, 0x6f, 0x42, + 0x50, 0x3c, 0x9c, 0x0c, 0x17, 0x91, 0xa9, 0x30, 0x21, 0x98, 0x16, 0xd5, 0x09, 0x91, 0xf4, 0xaf, + 0x09, 0xf4, 0x7a, 0x44, 0x15, 0xf9, 0x08, 0x18, 0x68, 0xbc, 0x94, 0x90, 0x6c, 0x93, 0xcc, 0x8a, + 0x4c, 0x97, 0xdb, 0x87, 0xca, 0xa0, 0xab, 0x46, 0xd7, 0xae, 0x82, 0x5f, 0x2b, 0xb0, 0x9f, 0x15, + 0x3a, 0x39, 0xbf, 0x8c, 0x66, 0xdd, 0xbf, 0x43, 0xf3, 0x96, 0x05, 0x34, 0xc9, 0xbe, 0xc8, 0xb6, + 0x30, 0x25, 0x7d, 0x3f, 0x81, 0xee, 0x9e, 0xfc, 0x35, 0x2e, 0x75, 0xef, 0xfa, 0xa4, 0xae, 0x58, + 0x88, 0x3b, 0x35, 0x58, 0x4c, 0x79, 0xf3, 0x54, 0x8e, 0x41, 0xaa, 0x0a, 0x58, 0x50, 0x25, 0x97, + 0x46, 0xe0, 0xd8, 0xcc, 0x71, 0x9c, 0xe2, 0xe5, 0x8f, 0x12, 0x82, 0x92, 0xaf, 0x6b, 0x99, 0x28, + 0x16, 0x82, 0xc7, 0x63, 0xb7, 0x54, 0xc0, 0x43, 0xc8, 0xf0, 0xe9, 0x45, 0x35, 0xbd, 0x7a, 0xe7, + 0x99, 0x3f, 0xb9, 0xbc, 0xe2, 0xae, 0x99, 0xea, 0x77, 0x5f, 0x95, 0x47, 0x6a, 0x1f, 0x42, 0x6c, + 0x72, 0x2f, 0x96, 0xb6, 0xc6, 0x87, 0x2a, 0x75, 0xc3, 0x32, 0xa1, 0x25, 0x0f, 0x4e, 0xa6, 0x88, + 0xc1, 0x68, 0xeb, 0xfd, 0x61, 0x4f, 0x25, 0xbc, 0x99, 0xb0, 0xae, 0x60, 0x94, 0x23, 0x45, 0xeb, + 0x29, 0x07, 0x3d, 0x55, 0xb6, 0xae, 0x83, 0x26, 0x69, 0x55, 0xc1, 0x88, 0x22, 0x07, 0xf3, 0x66, + 0x2f, 0x59, 0x71, 0x13, 0x47, 0x90, 0xd2, 0xd7, 0x53, 0x02, 0x59, 0xf1, 0x7c, 0xf5, 0x74, 0xb2, + 0x12, 0x32, 0x35, 0x28, 0x2b, 0x42, 0x63, 0x24, 0x88, 0x22, 0x6e, 0xa2, 0x6b, 0xde, 0xc2, 0x9b, + 0xd7, 0xe0, 0x80, 0x39, 0x7a, 0x15, 0xdd, 0xb2, 0x8c, 0x95, 0xc7, 0x14, 0x91, 0x8c, 0xbb, 0xba, + 0x57, 0xde, 0x68, 0x6d, 0xd5, 0x37, 0xc1, 0x28, 0x45, 0xe6, 0xe3, 0x69, 0xc7, 0x69, 0x11, 0x00, + 0x45, 0x69, 0xca, 0xad, 0xfd, 0xbd, 0xba, 0xdb, 0x54, 0xed, 0x6e, 0x97, 0x9f, 0xd6, 0xec, 0x9d, + 0x80, 0xa9, 0xb2, 0xed, 0x24, 0x87, 0xec, 0xd7, 0xcb, 0x8f, 0xc1, 0x62, 0x92, 0xfb, 0x74, 0x30, + 0x58, 0xb6, 0x9d, 0xe4, 0x50, 0x30, 0x50, 0xec, 0x08, 0xcd, 0xed, 0x46, 0xab, 0x89, 0xa7, 0x88, + 0xab, 0x0a, 0xcb, 0x98, 0xf7, 0x68, 0xcd, 0xa9, 0x79, 0xac, 0x0c, 0x3f, 0x47, 0xa5, 0x15, 0xe4, + 0x15, 0xa2, 0xe9, 0xfe, 0x90, 0x8b, 0xb0, 0x73, 0x47, 0x9a, 0xf6, 0xdd, 0x91, 0xd2, 0x78, 0x5a, + 0xfa, 0xaf, 0x60, 0x94, 0xef, 0xdf, 0x4a, 0xdc, 0xab, 0x80, 0xf0, 0x79, 0x41, 0x49, 0xf8, 0xed, + 0xd3, 0x09, 0x42, 0x24, 0xff, 0x5c, 0x75, 0x6c, 0x4a, 0x5c, 0x9b, 0x47, 0x29, 0x67, 0x39, 0x02, + 0xb0, 0x1c, 0x41, 0x5a, 0xfa, 0x24, 0xe8, 0x08, 0x9c, 0x8d, 0x97, 0x3b, 0x9d, 0xea, 0x48, 0x7f, + 0x59, 0xf2, 0x83, 0x59, 0x50, 0x3a, 0x1d, 0xb7, 0xce, 0x65, 0x9c, 0x7b, 0x71, 0x7d, 0xe8, 0x06, + 0xd0, 0xaa, 0x9c, 0xf4, 0x59, 0x32, 0xa0, 0x8c, 0x21, 0x7b, 0x89, 0xab, 0x8c, 0xc2, 0xa9, 0x41, + 0x16, 0xfc, 0x75, 0xe2, 0x4c, 0x79, 0x70, 0x03, 0xe5, 0x7d, 0x02, 0xdf, 0x92, 0x1d, 0x85, 0x48, + 0x05, 0xd4, 0x85, 0xaa, 0x5a, 0x9d, 0xc6, 0x81, 0xa0, 0x81, 0xb6, 0xba, 0xb4, 0xf6, 0xca, 0x55, + 0xa7, 0x8c, 0xbe, 0x5b, 0xab, 0x57, 0x89, 0x06, 0x67, 0x42, 0xee, 0xf8, 0xc8, 0x51, 0x5b, 0x23, + 0xa5, 0x13, 0xc7, 0x67, 0x4b, 0x9f, 0x84, 0x47, 0x63, 0xd6, 0xfc, 0xd3, 0x44, 0x63, 0xde, 0x39, + 0xc1, 0x68, 0x6c, 0x1d, 0x4d, 0x98, 0x14, 0x85, 0xf7, 0x89, 0xdd, 0x8d, 0xb1, 0x08, 0xfd, 0x99, + 0xff, 0x4e, 0x02, 0x65, 0xe8, 0x7f, 0x5e, 0x25, 0x16, 0x5f, 0x55, 0x15, 0x9d, 0xda, 0x53, 0xc8, + 0x35, 0x56, 0xca, 0xca, 0x66, 0x02, 0x7e, 0xc0, 0xb6, 0x04, 0xa1, 0x40, 0x6e, 0x16, 0x58, 0x9d, + 0x88, 0x78, 0x52, 0x2e, 0xa9, 0x67, 0x95, 0x02, 0xfe, 0x41, 0xb8, 0xb9, 0xa1, 0x27, 0xaf, 0x28, + 0x83, 0xb6, 0xda, 0x8b, 0xa1, 0x7b, 0xe0, 0xac, 0x1d, 0xdd, 0xe3, 0x57, 0x74, 0x22, 0x42, 0xa4, + 0x43, 0x66, 0x58, 0xb6, 0xef, 0x27, 0x89, 0x40, 0x5d, 0x20, 0xb0, 0x99, 0xb8, 0x75, 0x01, 0xc1, + 0xc4, 0xa0, 0xea, 0x7d, 0x70, 0x46, 0x65, 0x66, 0x3b, 0xd6, 0x26, 0xe1, 0x2f, 0x51, 0x1c, 0x9c, + 0x92, 0x7e, 0x27, 0x54, 0x51, 0x98, 0x4d, 0x78, 0x49, 0x9b, 0x16, 0x56, 0xf4, 0x4c, 0x05, 0x9d, + 0x0d, 0xeb, 0x9e, 0xfb, 0x7a, 0x32, 0x54, 0xd3, 0xac, 0x0d, 0x9c, 0x46, 0xd3, 0xbc, 0x73, 0x42, + 0xf3, 0x9e, 0x80, 0xf4, 0xf2, 0xae, 0x43, 0x52, 0x19, 0xe5, 0x30, 0xde, 0xd8, 0x48, 0x42, 0xf2, + 0xa9, 0x5f, 0x56, 0x81, 0x7f, 0x13, 0x2d, 0x86, 0x56, 0x30, 0xde, 0xd1, 0x0c, 0x7d, 0xa4, 0xb5, + 0x95, 0x1e, 0x09, 0x51, 0xe3, 0xd8, 0xad, 0x8f, 0x27, 0xd0, 0x1b, 0xb1, 0x56, 0xe2, 0x74, 0xdd, + 0xf1, 0xd1, 0x75, 0xa5, 0x70, 0x8a, 0xd9, 0x41, 0x0a, 0x6f, 0x92, 0xd6, 0x3b, 0xc0, 0xe0, 0xa6, + 0x6c, 0xfd, 0x54, 0xab, 0xd9, 0xc5, 0x2a, 0xd3, 0xc8, 0x7f, 0x9c, 0x44, 0x97, 0x5c, 0xd5, 0xa8, + 0x72, 0xbb, 0x3d, 0xee, 0x8f, 0x7b, 0x8a, 0xa9, 0x8f, 0x48, 0x2a, 0x43, 0x0b, 0x75, 0xaa, 0xc1, + 0x45, 0x90, 0xd4, 0xab, 0x49, 0xb3, 0xa1, 0xd5, 0x5e, 0x68, 0x77, 0x1b, 0xa6, 0x7c, 0xdd, 0x86, + 0x69, 0x7f, 0xb7, 0x61, 0x26, 0xd8, 0x6d, 0x38, 0xe1, 0xeb, 0x36, 0x9c, 0x74, 0x77, 0x1b, 0x4e, + 0x79, 0xba, 0x0d, 0xa7, 0xbd, 0xdd, 0x86, 0xc8, 0xdf, 0x6d, 0x38, 0x13, 0xd6, 0x6d, 0x38, 0x1b, + 0xda, 0x6d, 0x38, 0x67, 0x2f, 0x45, 0x4b, 0x68, 0xb4, 0x7f, 0x30, 0xff, 0x9f, 0x09, 0x34, 0xe3, + 0xa2, 0x89, 0xe8, 0x3e, 0x8a, 0xf4, 0x41, 0x18, 0x5c, 0xf3, 0x3e, 0x40, 0x73, 0x94, 0xfe, 0x76, + 0xab, 0x62, 0x9a, 0x96, 0xbb, 0x2a, 0x2f, 0xc3, 0x07, 0x3f, 0xdd, 0x65, 0x94, 0xb5, 0xd6, 0x76, + 0xb5, 0x3a, 0x66, 0xce, 0xec, 0x03, 0x67, 0xe6, 0x2f, 0x36, 0x03, 0x6d, 0x97, 0x3b, 0xac, 0xdf, + 0x1b, 0x42, 0x9c, 0x28, 0x53, 0x46, 0x04, 0x8b, 0x21, 0xf2, 0x8e, 0xab, 0xae, 0xd3, 0xd5, 0xe0, + 0x5d, 0x28, 0x4e, 0xd6, 0x7f, 0x91, 0xb2, 0x62, 0x64, 0xca, 0xee, 0x35, 0x69, 0x26, 0x49, 0xaa, + 0xd3, 0xd6, 0x20, 0x4b, 0xb0, 0xfe, 0x2d, 0x19, 0xb8, 0x2b, 0x76, 0xbe, 0x74, 0x62, 0x1f, 0x83, + 0x60, 0x46, 0x50, 0x3b, 0x1f, 0xa2, 0x29, 0xab, 0xf3, 0x5d, 0x14, 0x6b, 0x04, 0x16, 0xe1, 0x03, + 0xc4, 0x76, 0x0e, 0xc6, 0x7d, 0xd9, 0xd4, 0x4d, 0xa5, 0x27, 0xdb, 0xab, 0xd0, 0xed, 0xe7, 0x9f, + 0xa0, 0x49, 0x0b, 0x0d, 0x64, 0x94, 0x03, 0xc5, 0x74, 0xa5, 0xf9, 0xed, 0xd8, 0x3c, 0xd4, 0x43, + 0x1c, 0x04, 0xe8, 0x96, 0x53, 0xd1, 0x3f, 0x33, 0x89, 0x50, 0x51, 0xde, 0x77, 0xce, 0x3d, 0xb5, + 0xaf, 0x1f, 0xa9, 0xb4, 0xc7, 0xe1, 0xe5, 0xae, 0xef, 0xbc, 0x7e, 0x8f, 0xb1, 0xf1, 0xe7, 0xc1, + 0x12, 0xb2, 0xeb, 0x3b, 0xf1, 0x2f, 0x83, 0x42, 0x26, 0x05, 0x63, 0x82, 0xe3, 0x33, 0xf2, 0x4c, + 0x82, 0xea, 0x57, 0xca, 0x29, 0xad, 0xd1, 0xc8, 0xdc, 0x2a, 0xb9, 0xa5, 0xa5, 0x4a, 0x20, 0x00, + 0x6a, 0x82, 0x31, 0xee, 0x8c, 0x7b, 0x6a, 0x67, 0x87, 0xd9, 0xe5, 0x18, 0x7e, 0xea, 0x9f, 0x92, + 0x81, 0x8c, 0x2a, 0xb8, 0x0a, 0xa7, 0xd7, 0x96, 0x8f, 0x5e, 0x4b, 0x85, 0x98, 0x33, 0x83, 0x1a, + 0xf0, 0x14, 0x5d, 0x30, 0x2c, 0x64, 0x7e, 0x19, 0xd4, 0x51, 0x5e, 0x58, 0xda, 0xf0, 0x76, 0xec, + 0x85, 0xbd, 0x80, 0x2a, 0x2c, 0x91, 0xdf, 0x41, 0xd9, 0xe0, 0x68, 0x58, 0x60, 0x6e, 0xbd, 0xb0, + 0x70, 0x62, 0x0f, 0x90, 0x25, 0x9b, 0x3e, 0x06, 0xef, 0xb5, 0x3d, 0x65, 0x99, 0xec, 0x83, 0xb0, + 0x96, 0xc4, 0x23, 0xd5, 0xfb, 0x64, 0x22, 0x42, 0xd0, 0xa3, 0x4a, 0xc2, 0x3f, 0x0f, 0xbd, 0x19, + 0x71, 0x16, 0x8f, 0x2b, 0xd6, 0x21, 0x93, 0x3e, 0xb7, 0x58, 0x5f, 0x40, 0xd8, 0x11, 0x52, 0x2e, + 0xa2, 0xc9, 0x88, 0x76, 0x53, 0x97, 0x58, 0xd3, 0x72, 0x8f, 0x5c, 0xae, 0xb4, 0xb6, 0x1e, 0xd7, + 0x40, 0xac, 0x7f, 0x2f, 0x58, 0x10, 0x75, 0xf9, 0xa9, 0xaa, 0x6a, 0x2a, 0x5a, 0xcf, 0xf8, 0x7c, + 0x97, 0xd2, 0xde, 0x66, 0xbd, 0x54, 0xa0, 0x59, 0x8f, 0x19, 0xbd, 0x1f, 0xa6, 0xd1, 0xbd, 0x18, + 0x1b, 0xe1, 0x54, 0x7f, 0xcf, 0x47, 0xf5, 0x52, 0x21, 0xf6, 0xdc, 0xb0, 0x26, 0x89, 0x74, 0x47, + 0x31, 0x15, 0xae, 0x0e, 0x0f, 0x4f, 0xb1, 0x14, 0x03, 0x71, 0xb9, 0x37, 0x95, 0xfc, 0x0f, 0x92, + 0x68, 0xc1, 0x37, 0x46, 0x8e, 0x6a, 0xdf, 0xbf, 0x26, 0xe8, 0x5d, 0x08, 0xbd, 0x4c, 0x1b, 0x41, + 0x98, 0xe5, 0xa5, 0x11, 0x1b, 0x02, 0x77, 0xe3, 0xdc, 0x60, 0xf3, 0x31, 0xf3, 0xc5, 0xd0, 0xba, + 0xed, 0x75, 0x9e, 0xfa, 0x98, 0x9a, 0x3a, 0x72, 0x1e, 0x34, 0x39, 0xfc, 0x98, 0xb0, 0x4d, 0xf8, + 0x70, 0xa8, 0x1b, 0xa4, 0xf0, 0x6a, 0xbd, 0x7e, 0x9a, 0xb4, 0x93, 0x3f, 0x0f, 0x84, 0xde, 0xd2, + 0x4c, 0xd1, 0x9d, 0x05, 0x60, 0xf4, 0x3e, 0x67, 0x9a, 0xba, 0xaf, 0xbb, 0x56, 0x90, 0x8b, 0x4e, + 0x7a, 0xf0, 0x00, 0x27, 0x26, 0xee, 0xa3, 0x23, 0x1f, 0xbc, 0xa0, 0xd1, 0x20, 0xf5, 0x85, 0xb4, + 0x97, 0x0a, 0x12, 0x8c, 0x59, 0x5a, 0x87, 0xaf, 0x9c, 0x81, 0xbc, 0x4b, 0xdf, 0x9a, 0x46, 0x59, + 0x8b, 0x57, 0x2d, 0x7d, 0x3c, 0x22, 0x9b, 0x1d, 0x98, 0xd9, 0xd7, 0x51, 0x86, 0xec, 0x3d, 0xd8, + 0x74, 0xe7, 0xe0, 0x14, 0x48, 0xde, 0x44, 0x10, 0xbb, 0xf0, 0xd3, 0xb2, 0x83, 0xa1, 0x88, 0x9b, + 0xf0, 0x87, 0xc6, 0xc1, 0xdc, 0x57, 0x93, 0x6b, 0xb8, 0x39, 0xd3, 0x86, 0x5b, 0xad, 0x66, 0x73, + 0x60, 0x07, 0x16, 0x5c, 0xc3, 0x94, 0x63, 0x19, 0x2a, 0x9a, 0xb8, 0x50, 0x73, 0xd6, 0x6b, 0xc1, + 0xf8, 0xc3, 0x2b, 0xcf, 0x65, 0xdf, 0x90, 0xbc, 0x3f, 0x78, 0x3e, 0x00, 0x9a, 0x41, 0x62, 0x72, + 0xde, 0xbd, 0x8a, 0xda, 0x07, 0xa5, 0x32, 0x59, 0x57, 0xcb, 0x7c, 0xe9, 0x82, 0x67, 0x25, 0x0e, + 0x7b, 0x98, 0xf7, 0xae, 0xc6, 0x87, 0xe5, 0xba, 0x3e, 0x50, 0xbd, 0x82, 0x31, 0x19, 0xa2, 0x8d, + 0x53, 0x74, 0xec, 0x4b, 0x8c, 0xb5, 0x8c, 0xd3, 0xf3, 0xa5, 0x73, 0xee, 0xef, 0x90, 0x18, 0xd6, + 0xff, 0x11, 0x3a, 0x66, 0xef, 0x19, 0xc8, 0x38, 0xd0, 0x3b, 0xb4, 0x6f, 0x46, 0x48, 0xc6, 0x3a, + 0x20, 0xe4, 0xbf, 0x9b, 0x40, 0x69, 0x4a, 0x78, 0xd7, 0x8b, 0xbc, 0x44, 0xb0, 0x23, 0x31, 0x69, + 0xbd, 0x69, 0xa3, 0x43, 0xca, 0xc1, 0xc1, 0x48, 0x3d, 0xe2, 0x77, 0x8a, 0xe7, 0x9d, 0x77, 0x22, + 0xe4, 0xea, 0x7f, 0xee, 0x51, 0x12, 0x84, 0x03, 0x82, 0x27, 0x43, 0x55, 0xfd, 0x8f, 0xfb, 0x5c, + 0x8f, 0x75, 0xfc, 0x8f, 0x05, 0xd9, 0x03, 0x3f, 0xe0, 0x23, 0xd9, 0xb6, 0xac, 0xd3, 0x9e, 0x0a, + 0x93, 0xd3, 0x22, 0xff, 0xb3, 0x24, 0x4a, 0x53, 0xa6, 0xc3, 0x26, 0x89, 0x74, 0x78, 0x6a, 0x29, + 0x5d, 0x5d, 0xef, 0xd8, 0xea, 0x64, 0x47, 0xb6, 0x07, 0x8a, 0x33, 0x68, 0xdf, 0x86, 0x38, 0xa8, + 0x74, 0x73, 0xb3, 0x56, 0x74, 0x6c, 0x23, 0xd3, 0xe1, 0x39, 0xcb, 0x1a, 0xf6, 0xf4, 0x83, 0x83, + 0x17, 0x96, 0x34, 0x4d, 0x78, 0x8c, 0x46, 0xc6, 0x32, 0x1a, 0x74, 0x3b, 0xae, 0x2e, 0x27, 0x62, + 0x0b, 0xb4, 0x23, 0x55, 0xa6, 0x6d, 0x4a, 0xec, 0x51, 0xd8, 0x94, 0x3b, 0xec, 0x9c, 0xb6, 0xce, + 0xc9, 0xbb, 0x50, 0xe5, 0x67, 0x1a, 0xc9, 0x5d, 0xe8, 0x5b, 0x45, 0x90, 0x57, 0xce, 0xf3, 0x79, + 0xca, 0xf3, 0x8b, 0x6e, 0x9e, 0x93, 0xf3, 0x33, 0xbe, 0xdf, 0xf0, 0xf0, 0xdd, 0x1e, 0xb7, 0x79, + 0x0f, 0x5f, 0xa3, 0x44, 0x84, 0x6d, 0x2e, 0x84, 0x88, 0x17, 0x7d, 0xa6, 0x94, 0xff, 0x1f, 0xe0, + 0x3b, 0x11, 0x00, 0x37, 0xb6, 0x7d, 0xc1, 0x64, 0xd3, 0x42, 0x56, 0x1c, 0x8a, 0x3a, 0x83, 0x07, + 0x8e, 0x31, 0x3c, 0xd6, 0x06, 0xb4, 0x03, 0xcc, 0x7a, 0xdb, 0xc5, 0x22, 0x08, 0xdd, 0xb0, 0xc6, + 0x32, 0x61, 0x56, 0x93, 0x09, 0xfd, 0x16, 0x42, 0xf4, 0xc3, 0x0e, 0xa3, 0x7d, 0x27, 0x26, 0xdb, + 0x0b, 0x3b, 0xb1, 0x3d, 0x6e, 0x9f, 0xd8, 0x63, 0xbc, 0xa7, 0x45, 0x67, 0x96, 0xde, 0x77, 0xb2, + 0x31, 0x67, 0x35, 0xcb, 0x8f, 0x06, 0x4c, 0x08, 0xa3, 0xc6, 0x75, 0x74, 0x91, 0xbf, 0xdf, 0x75, + 0x41, 0xbb, 0x5c, 0xd2, 0xd2, 0xd2, 0x57, 0x9d, 0x70, 0xde, 0xbd, 0x24, 0xf7, 0x88, 0xe7, 0x3c, + 0x1e, 0x71, 0xee, 0x61, 0xa2, 0x04, 0x8a, 0x89, 0x9c, 0x85, 0xf8, 0xb3, 0xa3, 0xf3, 0x21, 0xda, + 0x29, 0xd5, 0xd0, 0x55, 0xfb, 0x4d, 0x26, 0xd8, 0x8b, 0x91, 0x97, 0xe3, 0xa2, 0xed, 0xba, 0x14, + 0x84, 0x45, 0x4c, 0x1f, 0xa0, 0xeb, 0xd6, 0x32, 0xbb, 0x8a, 0x01, 0xfb, 0x1a, 0x99, 0x8f, 0x75, + 0x53, 0x25, 0x2a, 0xbf, 0x09, 0xe7, 0x36, 0xbc, 0xe6, 0xc8, 0xd6, 0x7c, 0xce, 0x57, 0xb7, 0x46, + 0x8d, 0xc6, 0x64, 0x68, 0x3c, 0x74, 0x2e, 0xe3, 0xfe, 0xc8, 0x75, 0x0f, 0xe4, 0x5e, 0x7c, 0x53, + 0x05, 0x44, 0xad, 0x6d, 0xbf, 0xed, 0xcb, 0x3e, 0x46, 0x0b, 0xce, 0x3b, 0x40, 0x16, 0xcf, 0xb1, + 0x10, 0x41, 0x2a, 0x90, 0xb9, 0x72, 0x69, 0xa9, 0xb8, 0x6c, 0x2d, 0x60, 0xcf, 0xda, 0x1a, 0x74, + 0xb4, 0xb6, 0x6a, 0x3c, 0xbc, 0xb2, 0xbb, 0x5b, 0x5c, 0x26, 0x0f, 0x02, 0xe5, 0xf2, 0xf6, 0x76, + 0xb3, 0x55, 0xb6, 0xcb, 0xf0, 0x4b, 0x8c, 0xef, 0x1c, 0x9d, 0x9f, 0x77, 0x23, 0x78, 0xde, 0x26, + 0x89, 0x78, 0xd5, 0x0e, 0x8b, 0x01, 0x88, 0x16, 0x1b, 0x6e, 0x43, 0x97, 0xa6, 0xd2, 0x49, 0x50, + 0x64, 0xf6, 0x4e, 0x94, 0xad, 0xf3, 0xb6, 0xd3, 0xe0, 0x62, 0xad, 0xc3, 0x16, 0xa8, 0x28, 0xa3, + 0x4e, 0x85, 0xb4, 0x8f, 0xaa, 0xe4, 0x82, 0x9b, 0x98, 0x31, 0xeb, 0x87, 0x93, 0x52, 0x7c, 0x33, + 0x89, 0x2e, 0x84, 0x11, 0x26, 0x5b, 0xe2, 0xa9, 0x1a, 0x7b, 0x1c, 0xc8, 0x7c, 0xe1, 0x8d, 0x42, + 0x34, 0x83, 0xca, 0x28, 0xdb, 0x65, 0x04, 0x95, 0xed, 0xc3, 0x5a, 0xee, 0xf1, 0xd5, 0x42, 0x2c, + 0xfa, 0xaf, 0x01, 0xfd, 0x19, 0x11, 0xec, 0x3b, 0xdc, 0x94, 0xe0, 0xdb, 0x5e, 0x62, 0x55, 0xd1, + 0x25, 0x1e, 0x41, 0xb6, 0xe1, 0xd8, 0xb2, 0x7d, 0x54, 0xab, 0xcb, 0xeb, 0x4e, 0x21, 0x06, 0x91, + 0x20, 0x81, 0xa0, 0x7d, 0xf4, 0x16, 0x0a, 0x89, 0xc0, 0x2c, 0xad, 0x0b, 0x29, 0x24, 0x49, 0x3f, + 0x4d, 0xb3, 0xe7, 0xbc, 0x5e, 0x7c, 0xae, 0x52, 0x61, 0x95, 0x27, 0x47, 0xcd, 0x92, 0x96, 0x9a, + 0x2d, 0x92, 0xb6, 0x06, 0x53, 0x05, 0xfd, 0x30, 0xdd, 0xc5, 0xa1, 0x30, 0x4d, 0x83, 0x20, 0xea, + 0xa6, 0x4a, 0x8a, 0x6e, 0x1f, 0x8e, 0x95, 0x9e, 0xf6, 0x0c, 0x22, 0x38, 0x5a, 0xb3, 0x02, 0xe1, + 0x33, 0x9d, 0xee, 0x3d, 0x66, 0xb2, 0x00, 0xf3, 0x58, 0x3d, 0x01, 0x93, 0x79, 0xef, 0x1b, 0xe8, + 0x12, 0x9c, 0x9e, 0x58, 0x20, 0x9e, 0xdb, 0xd9, 0xf0, 0x69, 0xfe, 0xf8, 0x70, 0x9e, 0x6b, 0x5d, + 0x97, 0x30, 0x99, 0xbf, 0x25, 0x9e, 0x01, 0x03, 0x18, 0x2a, 0x37, 0xaf, 0xa1, 0x1b, 0xfe, 0x2d, + 0x72, 0x0d, 0xb5, 0x44, 0x99, 0xf5, 0xc7, 0xde, 0x43, 0xb7, 0xfc, 0x78, 0x4c, 0x6d, 0x65, 0xd0, + 0x5b, 0x0b, 0x95, 0x85, 0x7f, 0xb0, 0xa4, 0xff, 0x2c, 0xbe, 0x25, 0x67, 0xad, 0x25, 0xfd, 0x78, + 0xc1, 0x25, 0xe7, 0xac, 0xf8, 0x76, 0xc8, 0x77, 0x6d, 0xc8, 0x07, 0xfa, 0xb8, 0x7b, 0x68, 0x52, + 0x4f, 0x46, 0xad, 0x28, 0x84, 0xa1, 0x5d, 0xe2, 0xea, 0xe4, 0xe1, 0x78, 0x04, 0x72, 0x64, 0x30, + 0xeb, 0xb2, 0x10, 0x9a, 0xf2, 0xb1, 0x9e, 0x4b, 0x6c, 0x51, 0xd2, 0x0d, 0x53, 0x3f, 0x1a, 0x6a, + 0x23, 0xca, 0x54, 0xfe, 0xb6, 0x56, 0x42, 0x79, 0x37, 0x9c, 0x9c, 0xa2, 0xd7, 0xa3, 0x95, 0x73, + 0x59, 0x31, 0xd9, 0x4b, 0xdb, 0x45, 0x88, 0x1f, 0x2e, 0x84, 0xb9, 0x4c, 0x98, 0x7c, 0x82, 0x33, + 0x85, 0xf0, 0xf7, 0x0e, 0xba, 0x29, 0xc0, 0xb1, 0x93, 0x6c, 0x08, 0x78, 0x8a, 0xe8, 0x4d, 0x01, + 0xd6, 0x13, 0x45, 0x33, 0x21, 0x02, 0xdf, 0xd0, 0x47, 0xdb, 0x24, 0x9e, 0x68, 0xe9, 0x4d, 0xe2, + 0x97, 0x20, 0x35, 0xbc, 0x85, 0xae, 0x0b, 0xa6, 0x94, 0x41, 0x6d, 0x8f, 0x54, 0xc8, 0x10, 0x5f, + 0x43, 0x92, 0x00, 0xa5, 0xaa, 0x8d, 0xd4, 0xc7, 0x20, 0x78, 0xfa, 0xe8, 0x05, 0x4e, 0x93, 0x5e, + 0x02, 0x01, 0xde, 0x9e, 0xd2, 0xb1, 0xd0, 0x32, 0xd9, 0xdb, 0xe8, 0x15, 0x01, 0x1a, 0xbb, 0xf6, + 0x81, 0x93, 0x4c, 0x04, 0xce, 0xcb, 0x1b, 0xd1, 0x69, 0xf8, 0x6a, 0xd6, 0xc1, 0xff, 0x03, 0xd6, + 0xe4, 0xe2, 0xbf, 0x4f, 0x78, 0x48, 0x6a, 0x23, 0x05, 0x48, 0xea, 0x4c, 0x77, 0x48, 0x7a, 0x13, + 0x5d, 0x13, 0x7e, 0xa2, 0xa3, 0x16, 0x81, 0x9c, 0xb7, 0x85, 0xab, 0x10, 0x8c, 0x1d, 0xe5, 0x23, + 0xfc, 0xb5, 0x29, 0xa0, 0xce, 0x2d, 0x01, 0x52, 0xad, 0xa7, 0xf5, 0x41, 0xd8, 0x4c, 0xd8, 0xea, + 0xdf, 0xf6, 0x81, 0x3a, 0xa2, 0x13, 0x01, 0x53, 0x9e, 0xa9, 0xa4, 0x15, 0x09, 0xff, 0x1d, 0x49, + 0x3d, 0x24, 0x11, 0x9a, 0x36, 0xd0, 0x0c, 0xe0, 0x75, 0xd1, 0x30, 0xf1, 0xb7, 0xc6, 0x31, 0x10, + 0x4b, 0x83, 0x0e, 0xfe, 0x76, 0x1c, 0xc4, 0xe5, 0x51, 0x07, 0xff, 0x71, 0x1c, 0xc4, 0x15, 0xf3, + 0x10, 0x7f, 0x27, 0x0e, 0xe2, 0x2a, 0x20, 0xfe, 0x49, 0x1c, 0xc4, 0xfb, 0x80, 0xf8, 0xa7, 0x71, + 0x10, 0xd7, 0x00, 0xf1, 0xd3, 0x38, 0x88, 0xeb, 0x80, 0xf8, 0x67, 0x71, 0x10, 0x1f, 0x00, 0xe2, + 0x9f, 0x8f, 0xc1, 0x9c, 0xde, 0x3e, 0x89, 0xe0, 0x4b, 0x80, 0xf9, 0xdd, 0x58, 0x98, 0x45, 0xc0, + 0xfc, 0x5e, 0x2c, 0xcc, 0x12, 0x60, 0x7e, 0x16, 0x0b, 0x73, 0x19, 0x30, 0xbf, 0x1f, 0x0b, 0x93, + 0xb0, 0xe7, 0x07, 0xb1, 0x30, 0x09, 0x7f, 0xfe, 0x22, 0x16, 0x26, 0x61, 0xd0, 0x5f, 0x8e, 0x17, + 0xff, 0x25, 0x01, 0x89, 0xb6, 0x2f, 0xcf, 0x23, 0x2d, 0x0b, 0xe2, 0xec, 0x0f, 0x34, 0xec, 0x1a, + 0xca, 0x85, 0xc0, 0x9b, 0xaa, 0x39, 0x1e, 0xb2, 0xe6, 0xa4, 0x30, 0xa8, 0x6d, 0xce, 0x82, 0xb6, + 0x89, 0x61, 0x6c, 0x0d, 0x76, 0x47, 0x7a, 0x17, 0x7c, 0xad, 0x01, 0xb6, 0x29, 0x7c, 0x91, 0x8a, + 0xd5, 0x40, 0xc6, 0x3a, 0x23, 0xc2, 0x30, 0x2c, 0x53, 0x93, 0x59, 0xfc, 0x2b, 0xaf, 0x5d, 0xb6, + 0x03, 0xfb, 0x80, 0x11, 0x09, 0x84, 0xfc, 0x70, 0xc4, 0x02, 0x5a, 0x14, 0xe0, 0x10, 0x5a, 0x1a, + 0x60, 0xac, 0x9e, 0xaa, 0x66, 0xd9, 0x30, 0xb4, 0xee, 0x80, 0x5a, 0xe8, 0x7b, 0xe8, 0x55, 0x01, + 0xfe, 0xd6, 0xe0, 0x91, 0x6a, 0x1e, 0xab, 0xea, 0x80, 0xd8, 0x43, 0x03, 0x4e, 0x2f, 0x46, 0x25, + 0x18, 0x91, 0x54, 0x70, 0x50, 0xcb, 0xf2, 0x13, 0x7d, 0x00, 0x54, 0x10, 0x63, 0x3c, 0xa2, 0x18, + 0x41, 0xb3, 0xec, 0x60, 0x38, 0x66, 0x79, 0xf1, 0x7b, 0x17, 0xd1, 0xad, 0x13, 0x83, 0x65, 0x72, + 0xb9, 0x2b, 0x0c, 0x97, 0x81, 0x66, 0x11, 0xe0, 0x22, 0xeb, 0x93, 0x11, 0x81, 0x4b, 0xec, 0xe6, + 0x58, 0x04, 0x5e, 0x66, 0x9d, 0x6a, 0x22, 0xf0, 0x0a, 0xd0, 0x21, 0x02, 0xbc, 0x0a, 0x44, 0x88, + 0x00, 0xdf, 0x07, 0xaf, 0x14, 0x01, 0x5e, 0xc3, 0x93, 0x51, 0xe0, 0x75, 0x3c, 0x15, 0x05, 0x7e, + 0x80, 0xa7, 0x89, 0xb6, 0xd8, 0xe0, 0xf7, 0xf7, 0xcb, 0xdb, 0xbb, 0x7b, 0xb5, 0xaa, 0xfc, 0xa4, + 0xd6, 0x6c, 0x01, 0xd1, 0x50, 0x04, 0xb4, 0x88, 0x67, 0x22, 0xa0, 0x25, 0x3c, 0x1b, 0x01, 0x5d, + 0xc6, 0x73, 0x11, 0xd0, 0x15, 0x3c, 0x1f, 0x01, 0x5d, 0xc5, 0x0b, 0x11, 0xd0, 0xfb, 0x18, 0x47, + 0x40, 0xd7, 0xf0, 0xb9, 0x08, 0xe8, 0x3a, 0xce, 0x46, 0x40, 0x1f, 0xe0, 0xf3, 0x1e, 0x52, 0xfa, + 0xa8, 0xb1, 0x84, 0x2f, 0x44, 0x81, 0x8b, 0xf8, 0x62, 0x14, 0xb8, 0x84, 0x2f, 0x45, 0x81, 0x97, + 0xf1, 0xe5, 0x28, 0xf0, 0x0a, 0xce, 0x85, 0x6f, 0xbc, 0x56, 0xa6, 0x6c, 0xbc, 0x12, 0x01, 0x2d, + 0xe2, 0x7c, 0x04, 0xb4, 0x84, 0xaf, 0x46, 0x40, 0x97, 0xf1, 0xb5, 0x08, 0xe8, 0x0a, 0xbe, 0x1e, + 0x01, 0x5d, 0xc5, 0x37, 0x22, 0xa0, 0xf7, 0xf1, 0x2b, 0x11, 0xd0, 0x35, 0x7c, 0x33, 0x02, 0xba, + 0x8e, 0x6f, 0x45, 0x40, 0x1f, 0x60, 0x29, 0x9c, 0x94, 0x8c, 0x1a, 0x4b, 0xf8, 0x76, 0x14, 0xb8, + 0x88, 0xef, 0x44, 0x81, 0x4b, 0xf8, 0xd5, 0x28, 0xf0, 0x32, 0x7e, 0x2d, 0x0a, 0xbc, 0x82, 0x5f, + 0x27, 0x2d, 0xad, 0x36, 0x98, 0xf4, 0xd8, 0x55, 0xf6, 0x77, 0x59, 0xaf, 0xdd, 0x5d, 0xf2, 0x9c, + 0x3d, 0x00, 0x62, 0x7a, 0x8c, 0xef, 0x11, 0x9f, 0x18, 0x3a, 0x8f, 0xde, 0x23, 0xe2, 0x45, 0x62, + 0x88, 0x05, 0x93, 0x19, 0xc6, 0x1b, 0xa4, 0x63, 0xd6, 0xc6, 0xa8, 0x3d, 0xae, 0xd5, 0x5b, 0x74, + 0x67, 0x4b, 0xf8, 0x8b, 0x02, 0x48, 0x11, 0xbf, 0x29, 0x80, 0x94, 0x70, 0x41, 0x00, 0x59, 0xc6, + 0x6f, 0x09, 0x20, 0x2b, 0x78, 0x49, 0x00, 0x59, 0xc5, 0x45, 0x01, 0xe4, 0x3e, 0x2e, 0x09, 0x20, + 0x6b, 0x78, 0x59, 0x00, 0x59, 0xc7, 0x2b, 0x02, 0xc8, 0x03, 0xbc, 0xea, 0xa1, 0xbe, 0xeb, 0xa4, + 0x4b, 0xf8, 0xbe, 0x08, 0x54, 0xc4, 0x6b, 0x22, 0x50, 0x09, 0xaf, 0x8b, 0x40, 0xcb, 0xf8, 0x81, + 0x08, 0xb4, 0x82, 0x1f, 0x8a, 0x40, 0xab, 0xf8, 0x6d, 0x11, 0xe8, 0x3e, 0xfe, 0x92, 0x08, 0xb4, + 0x86, 0xbf, 0x2c, 0x02, 0xad, 0xe3, 0x5f, 0x11, 0x81, 0x1e, 0xe0, 0xaf, 0x08, 0x40, 0xa5, 0x25, + 0xfc, 0xab, 0x22, 0x50, 0x11, 0x97, 0x45, 0xa0, 0x12, 0x7e, 0x24, 0x02, 0x2d, 0xe3, 0x8a, 0x08, + 0xb4, 0x82, 0xab, 0x22, 0xd0, 0x2a, 0xae, 0x89, 0x40, 0xf7, 0xf1, 0x86, 0x08, 0xb4, 0x86, 0x37, + 0x45, 0xa0, 0x75, 0xfc, 0x8e, 0x08, 0xf4, 0x00, 0x6f, 0x09, 0x40, 0xcb, 0x4b, 0xf8, 0x5d, 0x11, + 0xa8, 0x88, 0xdf, 0x13, 0x81, 0x4a, 0x78, 0x5b, 0x04, 0x5a, 0xc6, 0x3b, 0x22, 0xd0, 0x0a, 0xae, + 0x8b, 0x40, 0xab, 0xb8, 0x21, 0x02, 0xdd, 0xc7, 0xbb, 0x22, 0xd0, 0x1a, 0x7e, 0x5f, 0x04, 0x5a, + 0xc7, 0x7b, 0x22, 0xd0, 0x03, 0xdc, 0x14, 0x80, 0x56, 0x96, 0x70, 0x4b, 0x04, 0x2a, 0xe2, 0x7d, + 0x11, 0xa8, 0x84, 0x1f, 0x8b, 0x40, 0xcb, 0xf8, 0x09, 0x79, 0x2d, 0x64, 0x83, 0x9a, 0x8d, 0xed, + 0x06, 0x18, 0xa5, 0xaf, 0x06, 0x07, 0x8b, 0xf8, 0x69, 0x70, 0xb0, 0x84, 0x3f, 0x08, 0x0e, 0x2e, + 0xe3, 0x5f, 0x0b, 0x0e, 0xae, 0xe0, 0x5f, 0x0f, 0x0e, 0xae, 0xe2, 0xdf, 0x08, 0x0e, 0xde, 0xc7, + 0xbf, 0x19, 0x1c, 0x5c, 0xc3, 0xf2, 0xa3, 0xcc, 0x3b, 0x89, 0xaf, 0x25, 0xbe, 0xf0, 0xff, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x28, 0xbf, 0xf3, 0xc9, 0x04, 0x53, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_common.pb.go b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_common.pb.go new file mode 100644 index 00000000..429f41ce --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/dota_common.pb.go @@ -0,0 +1,10997 @@ +// Code generated by protoc-gen-go. +// source: dota_gcmessages_common.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 protobuf is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type EDOTAGCMsg int32 + +const ( + EDOTAGCMsg_k_EMsgGCDOTABase EDOTAGCMsg = 7000 + EDOTAGCMsg_k_EMsgGCGeneralResponse EDOTAGCMsg = 7001 + EDOTAGCMsg_k_EMsgGCGameMatchSignOut EDOTAGCMsg = 7004 + EDOTAGCMsg_k_EMsgGCGameMatchSignOutResponse EDOTAGCMsg = 7005 + EDOTAGCMsg_k_EMsgGCJoinChatChannel EDOTAGCMsg = 7009 + EDOTAGCMsg_k_EMsgGCJoinChatChannelResponse EDOTAGCMsg = 7010 + EDOTAGCMsg_k_EMsgGCOtherJoinedChannel EDOTAGCMsg = 7013 + EDOTAGCMsg_k_EMsgGCOtherLeftChannel EDOTAGCMsg = 7014 + EDOTAGCMsg_k_EMsgGCMatchHistoryList EDOTAGCMsg = 7017 + EDOTAGCMsg_k_EMsgServerToGCRequestStatus EDOTAGCMsg = 7026 + EDOTAGCMsg_k_EMsgGCGetRecentMatches EDOTAGCMsg = 7027 + EDOTAGCMsg_k_EMsgGCRecentMatchesResponse EDOTAGCMsg = 7028 + EDOTAGCMsg_k_EMsgGCStartFindingMatch EDOTAGCMsg = 7033 + EDOTAGCMsg_k_EMsgGCConnectedPlayers EDOTAGCMsg = 7034 + EDOTAGCMsg_k_EMsgGCAbandonCurrentGame EDOTAGCMsg = 7035 + EDOTAGCMsg_k_EMsgGCStopFindingMatch EDOTAGCMsg = 7036 + EDOTAGCMsg_k_EMsgGCPracticeLobbyCreate EDOTAGCMsg = 7038 + EDOTAGCMsg_k_EMsgGCPracticeLobbyLeave EDOTAGCMsg = 7040 + EDOTAGCMsg_k_EMsgGCPracticeLobbyLaunch EDOTAGCMsg = 7041 + EDOTAGCMsg_k_EMsgGCPracticeLobbyList EDOTAGCMsg = 7042 + EDOTAGCMsg_k_EMsgGCPracticeLobbyListResponse EDOTAGCMsg = 7043 + EDOTAGCMsg_k_EMsgGCPracticeLobbyJoin EDOTAGCMsg = 7044 + EDOTAGCMsg_k_EMsgGCPracticeLobbySetDetails EDOTAGCMsg = 7046 + EDOTAGCMsg_k_EMsgGCPracticeLobbySetTeamSlot EDOTAGCMsg = 7047 + EDOTAGCMsg_k_EMsgGCInitialQuestionnaireResponse EDOTAGCMsg = 7049 + EDOTAGCMsg_k_EMsgGCTournamentRequest EDOTAGCMsg = 7051 + EDOTAGCMsg_k_EMsgGCTournamentResponse EDOTAGCMsg = 7052 + EDOTAGCMsg_k_EMsgGCPracticeLobbyResponse EDOTAGCMsg = 7055 + EDOTAGCMsg_k_EMsgGCBroadcastNotification EDOTAGCMsg = 7056 + EDOTAGCMsg_k_EMsgGCLiveScoreboardUpdate EDOTAGCMsg = 7057 + EDOTAGCMsg_k_EMsgGCRequestChatChannelList EDOTAGCMsg = 7060 + EDOTAGCMsg_k_EMsgGCRequestChatChannelListResponse EDOTAGCMsg = 7061 + EDOTAGCMsg_k_EMsgGCRequestMatches EDOTAGCMsg = 7064 + EDOTAGCMsg_k_EMsgGCRequestMatchesResponse EDOTAGCMsg = 7065 + EDOTAGCMsg_k_EMsgGCRequestPlayerResources EDOTAGCMsg = 7068 + EDOTAGCMsg_k_EMsgGCRequestPlayerResourcesResponse EDOTAGCMsg = 7069 + EDOTAGCMsg_k_EMsgGCReadyUp EDOTAGCMsg = 7070 + EDOTAGCMsg_k_EMsgGCKickedFromMatchmakingQueue EDOTAGCMsg = 7071 + EDOTAGCMsg_k_EMsgGCLeaverDetected EDOTAGCMsg = 7072 + EDOTAGCMsg_k_EMsgGCSpectateFriendGame EDOTAGCMsg = 7073 + EDOTAGCMsg_k_EMsgGCSpectateFriendGameResponse EDOTAGCMsg = 7074 + EDOTAGCMsg_k_EMsgGCPlayerReports EDOTAGCMsg = 7075 + EDOTAGCMsg_k_EMsgGCReportsRemainingRequest EDOTAGCMsg = 7076 + EDOTAGCMsg_k_EMsgGCReportsRemainingResponse EDOTAGCMsg = 7077 + EDOTAGCMsg_k_EMsgGCSubmitPlayerReport EDOTAGCMsg = 7078 + EDOTAGCMsg_k_EMsgGCSubmitPlayerReportResponse EDOTAGCMsg = 7079 + EDOTAGCMsg_k_EMsgGCGameChatLog EDOTAGCMsg = 7080 + EDOTAGCMsg_k_EMsgGCPracticeLobbyKick EDOTAGCMsg = 7081 + EDOTAGCMsg_k_EMsgGCReportCountsRequest EDOTAGCMsg = 7082 + EDOTAGCMsg_k_EMsgGCReportCountsResponse EDOTAGCMsg = 7083 + EDOTAGCMsg_k_EMsgGCRequestSaveGames EDOTAGCMsg = 7084 + EDOTAGCMsg_k_EMsgGCRequestSaveGamesServer EDOTAGCMsg = 7085 + EDOTAGCMsg_k_EMsgGCRequestSaveGamesResponse EDOTAGCMsg = 7086 + EDOTAGCMsg_k_EMsgGCLeaverDetectedResponse EDOTAGCMsg = 7087 + EDOTAGCMsg_k_EMsgGCPlayerFailedToConnect EDOTAGCMsg = 7088 + EDOTAGCMsg_k_EMsgGCGCToRelayConnect EDOTAGCMsg = 7089 + EDOTAGCMsg_k_EMsgGCGCToRelayConnectresponse EDOTAGCMsg = 7090 + EDOTAGCMsg_k_EMsgGCWatchGame EDOTAGCMsg = 7091 + EDOTAGCMsg_k_EMsgGCWatchGameResponse EDOTAGCMsg = 7092 + EDOTAGCMsg_k_EMsgGCBanStatusRequest EDOTAGCMsg = 7093 + EDOTAGCMsg_k_EMsgGCBanStatusResponse EDOTAGCMsg = 7094 + EDOTAGCMsg_k_EMsgGCMatchDetailsRequest EDOTAGCMsg = 7095 + EDOTAGCMsg_k_EMsgGCMatchDetailsResponse EDOTAGCMsg = 7096 + EDOTAGCMsg_k_EMsgGCCancelWatchGame EDOTAGCMsg = 7097 + EDOTAGCMsg_k_EMsgGCProfileRequest EDOTAGCMsg = 7098 + EDOTAGCMsg_k_EMsgGCProfileResponse EDOTAGCMsg = 7099 + EDOTAGCMsg_k_EMsgGCPopup EDOTAGCMsg = 7102 + EDOTAGCMsg_k_EMsgGCDOTAClearNotifySuccessfulReport EDOTAGCMsg = 7104 + EDOTAGCMsg_k_EMsgGCFriendPracticeLobbyListRequest EDOTAGCMsg = 7111 + EDOTAGCMsg_k_EMsgGCFriendPracticeLobbyListResponse EDOTAGCMsg = 7112 + EDOTAGCMsg_k_EMsgGCPracticeLobbyJoinResponse EDOTAGCMsg = 7113 + EDOTAGCMsg_k_EMsgClientEconNotification_Job EDOTAGCMsg = 7114 + EDOTAGCMsg_k_EMsgGCCreateTeam EDOTAGCMsg = 7115 + EDOTAGCMsg_k_EMsgGCCreateTeamResponse EDOTAGCMsg = 7116 + EDOTAGCMsg_k_EMsgGCDisbandTeam EDOTAGCMsg = 7117 + EDOTAGCMsg_k_EMsgGCDisbandTeamResponse EDOTAGCMsg = 7118 + EDOTAGCMsg_k_EMsgGCRequestTeamData EDOTAGCMsg = 7119 + EDOTAGCMsg_k_EMsgGCRequestTeamDataResponse EDOTAGCMsg = 7120 + EDOTAGCMsg_k_EMsgGCTeamData EDOTAGCMsg = 7121 + EDOTAGCMsg_k_EMsgGCTeamInvite_InviterToGC EDOTAGCMsg = 7122 + EDOTAGCMsg_k_EMsgGCTeamInvite_GCImmediateResponseToInviter EDOTAGCMsg = 7123 + EDOTAGCMsg_k_EMsgGCTeamInvite_GCRequestToInvitee EDOTAGCMsg = 7124 + EDOTAGCMsg_k_EMsgGCTeamInvite_InviteeResponseToGC EDOTAGCMsg = 7125 + EDOTAGCMsg_k_EMsgGCTeamInvite_GCResponseToInviter EDOTAGCMsg = 7126 + EDOTAGCMsg_k_EMsgGCTeamInvite_GCResponseToInvitee EDOTAGCMsg = 7127 + EDOTAGCMsg_k_EMsgGCKickTeamMember EDOTAGCMsg = 7128 + EDOTAGCMsg_k_EMsgGCKickTeamMemberResponse EDOTAGCMsg = 7129 + EDOTAGCMsg_k_EMsgGCLeaveTeam EDOTAGCMsg = 7130 + EDOTAGCMsg_k_EMsgGCLeaveTeamResponse EDOTAGCMsg = 7131 + EDOTAGCMsg_k_EMsgGCSuggestTeamMatchmaking EDOTAGCMsg = 7132 + EDOTAGCMsg_k_EMsgGCPlayerHeroesFavoritesAdd EDOTAGCMsg = 7133 + EDOTAGCMsg_k_EMsgGCPlayerHeroesFavoritesRemove EDOTAGCMsg = 7134 + EDOTAGCMsg_k_EMsgGCEditTeamLogo EDOTAGCMsg = 7139 + EDOTAGCMsg_k_EMsgGCEditTeamLogoResponse EDOTAGCMsg = 7140 + EDOTAGCMsg_k_EMsgGCSetShowcaseHero EDOTAGCMsg = 7141 + EDOTAGCMsg_k_EMsgGCApplyTeamToPracticeLobby EDOTAGCMsg = 7142 + EDOTAGCMsg_k_EMsgGCRequestInternatinalTicketEmail EDOTAGCMsg = 7143 + EDOTAGCMsg_k_EMsgGCTransferTeamAdmin EDOTAGCMsg = 7144 + EDOTAGCMsg_k_EMsgGCClearTournamentGame EDOTAGCMsg = 7145 + EDOTAGCMsg_k_EMsgRequestLeagueInfo EDOTAGCMsg = 7147 + EDOTAGCMsg_k_EMsgResponseLeagueInfo EDOTAGCMsg = 7148 + EDOTAGCMsg_k_EMsgGCPracticeLobbyJoinBroadcastChannel EDOTAGCMsg = 7149 + EDOTAGCMsg_k_EMsgGC_TournamentItemEvent EDOTAGCMsg = 7150 + EDOTAGCMsg_k_EMsgGC_TournamentItemEventResponse EDOTAGCMsg = 7151 + EDOTAGCMsg_k_EMsgCastMatchVote EDOTAGCMsg = 7152 + EDOTAGCMsg_k_EMsgCastMatchVoteResponse EDOTAGCMsg = 7153 + EDOTAGCMsg_k_EMsgRetrieveMatchVote EDOTAGCMsg = 7154 + EDOTAGCMsg_k_EMsgRetrieveMatchVoteResponse EDOTAGCMsg = 7155 + EDOTAGCMsg_k_EMsgTeamFanfare EDOTAGCMsg = 7156 + EDOTAGCMsg_k_EMsgResponseTeamFanfare EDOTAGCMsg = 7157 + EDOTAGCMsg_k_EMsgGC_GameServerUploadSaveGame EDOTAGCMsg = 7158 + EDOTAGCMsg_k_EMsgGC_GameServerSaveGameResult EDOTAGCMsg = 7159 + EDOTAGCMsg_k_EMsgGC_GameServerGetLoadGame EDOTAGCMsg = 7160 + EDOTAGCMsg_k_EMsgGC_GameServerGetLoadGameResult EDOTAGCMsg = 7161 + EDOTAGCMsg_k_EMsgGCTeamProfileRequest EDOTAGCMsg = 7164 + EDOTAGCMsg_k_EMsgGCTeamProfileResponse EDOTAGCMsg = 7165 + EDOTAGCMsg_k_EMsgGCEditTeamDetails EDOTAGCMsg = 7166 + EDOTAGCMsg_k_EMsgGCEditTeamDetailsResponse EDOTAGCMsg = 7167 + EDOTAGCMsg_k_EMsgGCProTeamListRequest EDOTAGCMsg = 7168 + EDOTAGCMsg_k_EMsgGCProTeamListResponse EDOTAGCMsg = 7169 + EDOTAGCMsg_k_EMsgGCReadyUpStatus EDOTAGCMsg = 7170 + EDOTAGCMsg_k_EMsgGCHallOfFame EDOTAGCMsg = 7171 + EDOTAGCMsg_k_EMsgGCHallOfFameRequest EDOTAGCMsg = 7172 + EDOTAGCMsg_k_EMsgGCHallOfFameResponse EDOTAGCMsg = 7173 + EDOTAGCMsg_k_EMsgGCGenerateDiretidePrizeList EDOTAGCMsg = 7174 + EDOTAGCMsg_k_EMsgGCRewardDiretidePrizes EDOTAGCMsg = 7176 + EDOTAGCMsg_k_EMsgGCDiretidePrizesRewardedResponse EDOTAGCMsg = 7177 + EDOTAGCMsg_k_EMsgGCHalloweenHighScoreRequest EDOTAGCMsg = 7178 + EDOTAGCMsg_k_EMsgGCHalloweenHighScoreResponse EDOTAGCMsg = 7179 + EDOTAGCMsg_k_EMsgGCGenerateDiretidePrizeListResponse EDOTAGCMsg = 7180 + EDOTAGCMsg_k_EMsgGCStorePromoPagesRequest EDOTAGCMsg = 7182 + EDOTAGCMsg_k_EMsgGCStorePromoPagesResponse EDOTAGCMsg = 7183 + EDOTAGCMsg_k_EMsgGCSpawnLootGreevil EDOTAGCMsg = 7184 + EDOTAGCMsg_k_EMsgGCDismissLootGreevil EDOTAGCMsg = 7185 + EDOTAGCMsg_k_EMsgGCToGCMatchCompleted EDOTAGCMsg = 7186 + EDOTAGCMsg_k_EMsgGCDismissLootGreevilResponse EDOTAGCMsg = 7187 + EDOTAGCMsg_k_EMsgGCBalancedShuffleLobby EDOTAGCMsg = 7188 + EDOTAGCMsg_k_EMsgGCToGCCheckLeaguePermission EDOTAGCMsg = 7189 + EDOTAGCMsg_k_EMsgGCToGCCheckLeaguePermissionResponse EDOTAGCMsg = 7190 + EDOTAGCMsg_k_EMsgGCLeagueScheduleRequest EDOTAGCMsg = 7191 + EDOTAGCMsg_k_EMsgGCLeagueScheduleResponse EDOTAGCMsg = 7192 + EDOTAGCMsg_k_EMsgGCLeagueScheduleEdit EDOTAGCMsg = 7193 + EDOTAGCMsg_k_EMsgGCLeagueScheduleEditResponse EDOTAGCMsg = 7194 + EDOTAGCMsg_k_EMsgGCLeaguesInMonthRequest EDOTAGCMsg = 7195 + EDOTAGCMsg_k_EMsgGCLeaguesInMonthResponse EDOTAGCMsg = 7196 + EDOTAGCMsg_k_EMsgGCMatchmakingStatsRequest EDOTAGCMsg = 7197 + EDOTAGCMsg_k_EMsgGCMatchmakingStatsResponse EDOTAGCMsg = 7198 + EDOTAGCMsg_k_EMsgGCBotGameCreate EDOTAGCMsg = 7199 + EDOTAGCMsg_k_EMsgGCSetMatchHistoryAccess EDOTAGCMsg = 7200 + EDOTAGCMsg_k_EMsgGCSetMatchHistoryAccessResponse EDOTAGCMsg = 7201 + EDOTAGCMsg_k_EMsgUpgradeLeagueItem EDOTAGCMsg = 7203 + EDOTAGCMsg_k_EMsgUpgradeLeagueItemResponse EDOTAGCMsg = 7204 + EDOTAGCMsg_k_EMsgGCTeamMemberProfileRequest EDOTAGCMsg = 7205 + EDOTAGCMsg_k_EMsgGCWatchDownloadedReplay EDOTAGCMsg = 7206 + EDOTAGCMsg_k_EMsgGCSetMapLocationState EDOTAGCMsg = 7207 + EDOTAGCMsg_k_EMsgGCSetMapLocationStateResponse EDOTAGCMsg = 7208 + EDOTAGCMsg_k_EMsgGCResetMapLocations EDOTAGCMsg = 7209 + EDOTAGCMsg_k_EMsgGCResetMapLocationsResponse EDOTAGCMsg = 7210 + EDOTAGCMsg_k_EMsgGCTeamOnProfile EDOTAGCMsg = 7211 + EDOTAGCMsg_k_EMsgGCSetFeaturedItems EDOTAGCMsg = 7212 + EDOTAGCMsg_k_EMsgGCFeaturedItems EDOTAGCMsg = 7215 + EDOTAGCMsg_k_EMsgRefreshPartnerAccountLink EDOTAGCMsg = 7216 + EDOTAGCMsg_k_EMsgClientsRejoinChatChannels EDOTAGCMsg = 7217 + EDOTAGCMsg_k_EMsgGCToGCGetUserChatInfo EDOTAGCMsg = 7218 + EDOTAGCMsg_k_EMsgGCToGCGetUserChatInfoResponse EDOTAGCMsg = 7219 + EDOTAGCMsg_k_EMsgGCToGCLeaveAllChatChannels EDOTAGCMsg = 7220 + EDOTAGCMsg_k_EMsgGCToGCUpdateAccountChatBan EDOTAGCMsg = 7221 + EDOTAGCMsg_k_EMsgGCGuildCreateRequest EDOTAGCMsg = 7222 + EDOTAGCMsg_k_EMsgGCGuildCreateResponse EDOTAGCMsg = 7223 + EDOTAGCMsg_k_EMsgGCGuildSetAccountRoleRequest EDOTAGCMsg = 7224 + EDOTAGCMsg_k_EMsgGCGuildSetAccountRoleResponse EDOTAGCMsg = 7225 + EDOTAGCMsg_k_EMsgGCRequestGuildData EDOTAGCMsg = 7226 + EDOTAGCMsg_k_EMsgGCGuildData EDOTAGCMsg = 7227 + EDOTAGCMsg_k_EMsgGCGuildInviteAccountRequest EDOTAGCMsg = 7228 + EDOTAGCMsg_k_EMsgGCGuildInviteAccountResponse EDOTAGCMsg = 7229 + EDOTAGCMsg_k_EMsgGCGuildCancelInviteRequest EDOTAGCMsg = 7230 + EDOTAGCMsg_k_EMsgGCGuildCancelInviteResponse EDOTAGCMsg = 7231 + EDOTAGCMsg_k_EMsgGCGuildUpdateDetailsRequest EDOTAGCMsg = 7232 + EDOTAGCMsg_k_EMsgGCGuildUpdateDetailsResponse EDOTAGCMsg = 7233 + EDOTAGCMsg_k_EMsgGCToGCCanInviteUser EDOTAGCMsg = 7234 + EDOTAGCMsg_k_EMsgGCToGCCanInviteUserResponse EDOTAGCMsg = 7235 + EDOTAGCMsg_k_EMsgGCToGCGetUserRank EDOTAGCMsg = 7236 + EDOTAGCMsg_k_EMsgGCToGCGetUserRankResponse EDOTAGCMsg = 7237 + EDOTAGCMsg_k_EMsgGCToGCUpdateTeamStats EDOTAGCMsg = 7240 + EDOTAGCMsg_k_EMsgGCToGCGetTeamRank EDOTAGCMsg = 7241 + EDOTAGCMsg_k_EMsgGCToGCGetTeamRankResponse EDOTAGCMsg = 7242 + EDOTAGCMsg_k_EMsgGCTeamIDByNameRequest EDOTAGCMsg = 7245 + EDOTAGCMsg_k_EMsgGCTeamIDByNameResponse EDOTAGCMsg = 7246 + EDOTAGCMsg_k_EMsgGCEditTeam EDOTAGCMsg = 7247 + EDOTAGCMsg_k_EMsgGCPassportDataRequest EDOTAGCMsg = 7248 + EDOTAGCMsg_k_EMsgGCPassportDataResponse EDOTAGCMsg = 7249 + EDOTAGCMsg_k_EMsgGCNotInGuildData EDOTAGCMsg = 7251 + EDOTAGCMsg_k_EMsgGCGuildInviteData EDOTAGCMsg = 7254 + EDOTAGCMsg_k_EMsgGCToGCGetLeagueAdmin EDOTAGCMsg = 7255 + EDOTAGCMsg_k_EMsgGCToGCGetLeagueAdminResponse EDOTAGCMsg = 7256 + EDOTAGCMsg_k_EMsgGCRequestLeaguePrizePool EDOTAGCMsg = 7258 + EDOTAGCMsg_k_EMsgGCRequestLeaguePrizePoolResponse EDOTAGCMsg = 7259 + EDOTAGCMsg_k_EMsgGCToGCUpdateOpenGuildPartyRequest EDOTAGCMsg = 7261 + EDOTAGCMsg_k_EMsgGCToGCUpdateOpenGuildPartyResponse EDOTAGCMsg = 7262 + EDOTAGCMsg_k_EMsgGCToGCDestroyOpenGuildPartyRequest EDOTAGCMsg = 7263 + EDOTAGCMsg_k_EMsgGCToGCDestroyOpenGuildPartyResponse EDOTAGCMsg = 7264 + EDOTAGCMsg_k_EMsgGCGuildUpdateMessage EDOTAGCMsg = 7265 + EDOTAGCMsg_k_EMsgGCPartySetOpenGuildRequest EDOTAGCMsg = 7266 + EDOTAGCMsg_k_EMsgGCPartySetOpenGuildResponse EDOTAGCMsg = 7267 + EDOTAGCMsg_k_EMsgGCGuildOpenPartyRefresh EDOTAGCMsg = 7268 + EDOTAGCMsg_k_EMsgGCJoinOpenGuildPartyRequest EDOTAGCMsg = 7269 + EDOTAGCMsg_k_EMsgGCJoinOpenGuildPartyResponse EDOTAGCMsg = 7270 + EDOTAGCMsg_k_EMsgGCLeaveChatChannel EDOTAGCMsg = 7272 + EDOTAGCMsg_k_EMsgGCChatMessage EDOTAGCMsg = 7273 + EDOTAGCMsg_k_EMsgGCGetHeroStandings EDOTAGCMsg = 7274 + EDOTAGCMsg_k_EMsgGCGetHeroStandingsResponse EDOTAGCMsg = 7275 + EDOTAGCMsg_k_EMsgGCGuildEditLogoRequest EDOTAGCMsg = 7279 + EDOTAGCMsg_k_EMsgGCGuildEditLogoResponse EDOTAGCMsg = 7280 + EDOTAGCMsg_k_EMsgGCGuildmatePracticeLobbyListRequest EDOTAGCMsg = 7281 + EDOTAGCMsg_k_EMsgGCGuildmatePracticeLobbyListResponse EDOTAGCMsg = 7282 + EDOTAGCMsg_k_EMsgGCItemEditorReservationsRequest EDOTAGCMsg = 7283 + EDOTAGCMsg_k_EMsgGCItemEditorReservationsResponse EDOTAGCMsg = 7284 + EDOTAGCMsg_k_EMsgGCItemEditorReserveItemDef EDOTAGCMsg = 7285 + EDOTAGCMsg_k_EMsgGCItemEditorReserveItemDefResponse EDOTAGCMsg = 7286 + EDOTAGCMsg_k_EMsgGCItemEditorReleaseReservation EDOTAGCMsg = 7287 + EDOTAGCMsg_k_EMsgGCItemEditorReleaseReservationResponse EDOTAGCMsg = 7288 + EDOTAGCMsg_k_EMsgGCRewardTutorialPrizes EDOTAGCMsg = 7289 + EDOTAGCMsg_k_EMsgGCLastHitChallengeHighScorePost EDOTAGCMsg = 7290 + EDOTAGCMsg_k_EMsgGCLastHitChallengeHighScoreRequest EDOTAGCMsg = 7291 + EDOTAGCMsg_k_EMsgGCLastHitChallengeHighScoreResponse EDOTAGCMsg = 7292 + EDOTAGCMsg_k_EMsgGCCreateFantasyLeagueRequest EDOTAGCMsg = 7293 + EDOTAGCMsg_k_EMsgGCCreateFantasyLeagueResponse EDOTAGCMsg = 7294 + EDOTAGCMsg_k_EMsgGCFantasyLeagueInfoRequest EDOTAGCMsg = 7297 + EDOTAGCMsg_k_EMsgGCFantasyLeagueInfoResponse EDOTAGCMsg = 7298 + EDOTAGCMsg_k_EMsgGCFantasyLeagueInfo EDOTAGCMsg = 7299 + EDOTAGCMsg_k_EMsgGCCreateFantasyTeamRequest EDOTAGCMsg = 7300 + EDOTAGCMsg_k_EMsgGCCreateFantasyTeamResponse EDOTAGCMsg = 7301 + EDOTAGCMsg_k_EMsgGCEditFantasyTeamRequest EDOTAGCMsg = 7302 + EDOTAGCMsg_k_EMsgGCEditFantasyTeamResponse EDOTAGCMsg = 7303 + EDOTAGCMsg_k_EMsgGCFantasyTeamInfoRequestByFantasyLeagueID EDOTAGCMsg = 7304 + EDOTAGCMsg_k_EMsgGCFantasyTeamInfoRequestByOwnerAccountID EDOTAGCMsg = 7305 + EDOTAGCMsg_k_EMsgGCFantasyTeamInfoResponse EDOTAGCMsg = 7306 + EDOTAGCMsg_k_EMsgGCFantasyTeamInfo EDOTAGCMsg = 7307 + EDOTAGCMsg_k_EMsgGCFantasyLivePlayerStats EDOTAGCMsg = 7308 + EDOTAGCMsg_k_EMsgGCFantasyFinalPlayerStats EDOTAGCMsg = 7309 + EDOTAGCMsg_k_EMsgGCFantasyMatch EDOTAGCMsg = 7310 + EDOTAGCMsg_k_EMsgGCToGCReloadVersions EDOTAGCMsg = 7311 + EDOTAGCMsg_k_EMsgGCFantasyTeamScoreRequest EDOTAGCMsg = 7312 + EDOTAGCMsg_k_EMsgGCFantasyTeamScoreResponse EDOTAGCMsg = 7313 + EDOTAGCMsg_k_EMsgGCFantasyTeamStandingsRequest EDOTAGCMsg = 7314 + EDOTAGCMsg_k_EMsgGCFantasyTeamStandingsResponse EDOTAGCMsg = 7315 + EDOTAGCMsg_k_EMsgGCFantasyPlayerScoreRequest EDOTAGCMsg = 7316 + EDOTAGCMsg_k_EMsgGCFantasyPlayerScoreResponse EDOTAGCMsg = 7317 + EDOTAGCMsg_k_EMsgGCFantasyPlayerStandingsRequest EDOTAGCMsg = 7318 + EDOTAGCMsg_k_EMsgGCFantasyPlayerStandingsResponse EDOTAGCMsg = 7319 + EDOTAGCMsg_k_EMsgGCFlipLobbyTeams EDOTAGCMsg = 7320 + EDOTAGCMsg_k_EMsgGCCustomGameCreate EDOTAGCMsg = 7321 + EDOTAGCMsg_k_EMsgGCFantasyPlayerInfoRequest EDOTAGCMsg = 7322 + EDOTAGCMsg_k_EMsgGCFantasyPlayerInfoResponse EDOTAGCMsg = 7323 + EDOTAGCMsg_k_EMsgGCToGCProcessPlayerReportForTarget EDOTAGCMsg = 7324 + EDOTAGCMsg_k_EMsgGCToGCProcessReportSuccess EDOTAGCMsg = 7325 + EDOTAGCMsg_k_EMsgGCNotifyAccountFlagsChange EDOTAGCMsg = 7326 + EDOTAGCMsg_k_EMsgGCSetProfilePrivacy EDOTAGCMsg = 7327 + EDOTAGCMsg_k_EMsgGCSetProfilePrivacyResponse EDOTAGCMsg = 7328 + EDOTAGCMsg_k_EMsgGCSteamProfileRequest EDOTAGCMsg = 7329 + EDOTAGCMsg_k_EMsgGCSteamProfileRequestResponse EDOTAGCMsg = 7330 + EDOTAGCMsg_k_EMsgGCFantasyLeagueCreateInfoRequest EDOTAGCMsg = 7331 + EDOTAGCMsg_k_EMsgGCFantasyLeagueCreateInfoResponse EDOTAGCMsg = 7332 + EDOTAGCMsg_k_EMsgGCFantasyLeagueInviteInfoRequest EDOTAGCMsg = 7333 + EDOTAGCMsg_k_EMsgGCFantasyLeagueInviteInfoResponse EDOTAGCMsg = 7334 + EDOTAGCMsg_k_EMsgGCClientIgnoredUser EDOTAGCMsg = 7335 + EDOTAGCMsg_k_EMsgGCFantasyLeagueCreateRequest EDOTAGCMsg = 7336 + EDOTAGCMsg_k_EMsgGCFantasyLeagueCreateResponse EDOTAGCMsg = 7337 + EDOTAGCMsg_k_EMsgGCFantasyTeamCreateRequest EDOTAGCMsg = 7338 + EDOTAGCMsg_k_EMsgGCFantasyTeamCreateResponse EDOTAGCMsg = 7339 + EDOTAGCMsg_k_EMsgGCFantasyLeagueFriendJoinListRequest EDOTAGCMsg = 7340 + EDOTAGCMsg_k_EMsgGCFantasyLeagueFriendJoinListResponse EDOTAGCMsg = 7341 + EDOTAGCMsg_k_EMsgGCClientSuspended EDOTAGCMsg = 7342 + EDOTAGCMsg_k_EMsgGCPartyMemberSetCoach EDOTAGCMsg = 7343 + EDOTAGCMsg_k_EMsgGCFantasyLeagueEditInvitesRequest EDOTAGCMsg = 7344 + EDOTAGCMsg_k_EMsgGCFantasyLeagueEditInvitesResponse EDOTAGCMsg = 7345 + EDOTAGCMsg_k_EMsgGCPracticeLobbySetCoach EDOTAGCMsg = 7346 + EDOTAGCMsg_k_EMsgGCFantasyLeagueEditInfoRequest EDOTAGCMsg = 7347 + EDOTAGCMsg_k_EMsgGCFantasyLeagueEditInfoResponse EDOTAGCMsg = 7348 + EDOTAGCMsg_k_EMsgGCFantasyLeagueDraftStatusRequest EDOTAGCMsg = 7349 + EDOTAGCMsg_k_EMsgGCFantasyLeagueDraftStatus EDOTAGCMsg = 7350 + EDOTAGCMsg_k_EMsgGCFantasyLeagueDraftPlayerRequest EDOTAGCMsg = 7351 + EDOTAGCMsg_k_EMsgGCFantasyLeagueDraftPlayerResponse EDOTAGCMsg = 7352 + EDOTAGCMsg_k_EMsgGCFantasyLeagueMatchupsRequest EDOTAGCMsg = 7353 + EDOTAGCMsg_k_EMsgGCFantasyLeagueMatchupsResponse EDOTAGCMsg = 7354 + EDOTAGCMsg_k_EMsgGCFantasyTeamRosterSwapRequest EDOTAGCMsg = 7355 + EDOTAGCMsg_k_EMsgGCFantasyTeamRosterSwapResponse EDOTAGCMsg = 7356 + EDOTAGCMsg_k_EMsgGCFantasyTeamRosterRequest EDOTAGCMsg = 7357 + EDOTAGCMsg_k_EMsgGCFantasyTeamRosterResponse EDOTAGCMsg = 7358 + EDOTAGCMsg_k_EMsgGCNexonPartnerUpdate EDOTAGCMsg = 7359 + EDOTAGCMsg_k_EMsgGCToGCProcessPCBangRewardPoints EDOTAGCMsg = 7360 + EDOTAGCMsg_k_EMsgGCFantasyTeamRosterAddDropRequest EDOTAGCMsg = 7361 + EDOTAGCMsg_k_EMsgGCFantasyTeamRosterAddDropResponse EDOTAGCMsg = 7362 + EDOTAGCMsg_k_EMsgPresentedClientTerminateDlg EDOTAGCMsg = 7363 + EDOTAGCMsg_k_EMsgGCFantasyPlayerHisoricalStatsRequest EDOTAGCMsg = 7364 + EDOTAGCMsg_k_EMsgGCFantasyPlayerHisoricalStatsResponse EDOTAGCMsg = 7365 + EDOTAGCMsg_k_EMsgGCPCBangTimedRewardMessage EDOTAGCMsg = 7366 + EDOTAGCMsg_k_EMsgGCLobbyUpdateBroadcastChannelInfo EDOTAGCMsg = 7367 + EDOTAGCMsg_k_EMsgGCFantasyTeamTradesRequest EDOTAGCMsg = 7368 + EDOTAGCMsg_k_EMsgGCFantasyTeamTradesResponse EDOTAGCMsg = 7369 + EDOTAGCMsg_k_EMsgGCFantasyTeamTradeCancelRequest EDOTAGCMsg = 7370 + EDOTAGCMsg_k_EMsgGCFantasyTeamTradeCancelResponse EDOTAGCMsg = 7371 + EDOTAGCMsg_k_EMsgGCToGCGrantTournamentItem EDOTAGCMsg = 7372 + EDOTAGCMsg_k_EMsgGCProcessFantasyScheduledEvent EDOTAGCMsg = 7373 + EDOTAGCMsg_k_EMsgGCToGCGrantPCBangRewardItem EDOTAGCMsg = 7374 + EDOTAGCMsg_k_EMsgGCToGCUpgradeTwitchViewerItems EDOTAGCMsg = 7375 + EDOTAGCMsg_k_EMsgGCToGCGetLiveMatchAffiliates EDOTAGCMsg = 7376 + EDOTAGCMsg_k_EMsgGCToGCGetLiveMatchAffiliatesResponse EDOTAGCMsg = 7377 + EDOTAGCMsg_k_EMsgGCToGCUpdatePlayerPennantCounts EDOTAGCMsg = 7378 + EDOTAGCMsg_k_EMsgGCToGCGetPlayerPennantCounts EDOTAGCMsg = 7379 + EDOTAGCMsg_k_EMsgGCToGCGetPlayerPennantCountsResponse EDOTAGCMsg = 7380 + EDOTAGCMsg_k_EMsgGCGameMatchSignOutPermissionRequest EDOTAGCMsg = 7381 + EDOTAGCMsg_k_EMsgGCGameMatchSignOutPermissionResponse EDOTAGCMsg = 7382 + EDOTAGCMsg_k_EMsgDOTAChatChannelMemberUpdate EDOTAGCMsg = 7383 + EDOTAGCMsg_k_EMsgDOTAAwardEventPoints EDOTAGCMsg = 7384 + EDOTAGCMsg_k_EMsgDOTARedeemEventPrize EDOTAGCMsg = 7385 + EDOTAGCMsg_k_EMsgDOTARedeemEventPrizeResponse EDOTAGCMsg = 7386 + EDOTAGCMsg_k_EMsgDOTAGetEventPoints EDOTAGCMsg = 7387 + EDOTAGCMsg_k_EMsgDOTAGetEventPointsResponse EDOTAGCMsg = 7388 + EDOTAGCMsg_k_EMsgGCToGCSignoutAwardEventPoints EDOTAGCMsg = 7390 + EDOTAGCMsg_k_EMsgDOTASendFriendRecruits EDOTAGCMsg = 7393 + EDOTAGCMsg_k_EMsgDOTAFriendRecruitsRequest EDOTAGCMsg = 7394 + EDOTAGCMsg_k_EMsgDOTAFriendRecruitsResponse EDOTAGCMsg = 7395 + EDOTAGCMsg_k_EMsgDOTAFriendRecruitInviteAcceptDecline EDOTAGCMsg = 7396 + EDOTAGCMsg_k_EMsgGCPartyLeaderWatchGamePrompt EDOTAGCMsg = 7397 + EDOTAGCMsg_k_EMsgDOTAFrostivusTimeElapsed EDOTAGCMsg = 7398 + EDOTAGCMsg_k_EMsgGCToGCGrantEarnedLicense EDOTAGCMsg = 7399 + EDOTAGCMsg_k_EMsgDOTALiveLeagueGameUpdate EDOTAGCMsg = 7402 + EDOTAGCMsg_k_EMsgDOTAChatGetUserList EDOTAGCMsg = 7403 + EDOTAGCMsg_k_EMsgDOTAChatGetUserListResponse EDOTAGCMsg = 7404 + EDOTAGCMsg_k_EMsgGCCompendiumSetSelection EDOTAGCMsg = 7405 + EDOTAGCMsg_k_EMsgGCCompendiumDataRequest EDOTAGCMsg = 7406 + EDOTAGCMsg_k_EMsgGCCompendiumDataResponse EDOTAGCMsg = 7407 + EDOTAGCMsg_k_EMsgDOTAGetPlayerMatchHistory EDOTAGCMsg = 7408 + EDOTAGCMsg_k_EMsgDOTAGetPlayerMatchHistoryResponse EDOTAGCMsg = 7409 + EDOTAGCMsg_k_EMsgGCToGCMatchmakingAddParty EDOTAGCMsg = 7410 + EDOTAGCMsg_k_EMsgGCToGCMatchmakingRemoveParty EDOTAGCMsg = 7411 + EDOTAGCMsg_k_EMsgGCToGCMatchmakingRemoveAllParties EDOTAGCMsg = 7412 + EDOTAGCMsg_k_EMsgGCToGCMatchmakingMatchFound EDOTAGCMsg = 7413 + EDOTAGCMsg_k_EMsgGCToGCUpdateMatchManagementStats EDOTAGCMsg = 7414 + EDOTAGCMsg_k_EMsgGCToGCUpdateMatchmakingStats EDOTAGCMsg = 7415 + EDOTAGCMsg_k_EMsgGCToServerPingRequest EDOTAGCMsg = 7416 + EDOTAGCMsg_k_EMsgGCToServerPingResponse EDOTAGCMsg = 7417 + EDOTAGCMsg_k_EMsgGCToServerConsoleCommand EDOTAGCMsg = 7418 + EDOTAGCMsg_k_EMsgGCToGCUpdateLiveLeagueGameInfo EDOTAGCMsg = 7420 + EDOTAGCMsg_k_EMsgGCMakeOffering EDOTAGCMsg = 7423 + EDOTAGCMsg_k_EMsgGCRequestOfferings EDOTAGCMsg = 7424 + EDOTAGCMsg_k_EMsgGCRequestOfferingsResponse EDOTAGCMsg = 7425 + EDOTAGCMsg_k_EMsgGCToGCProcessMatchLeaver EDOTAGCMsg = 7426 + EDOTAGCMsg_k_EMsgGCNotificationsRequest EDOTAGCMsg = 7427 + EDOTAGCMsg_k_EMsgGCNotificationsResponse EDOTAGCMsg = 7428 + EDOTAGCMsg_k_EMsgGCToGCModifyNotification EDOTAGCMsg = 7429 + EDOTAGCMsg_k_EMsgGCToGCSetNewNotifications EDOTAGCMsg = 7430 + EDOTAGCMsg_k_EMsgGCToGCSetIsLeagueAdmin EDOTAGCMsg = 7431 + EDOTAGCMsg_k_EMsgGCLeagueAdminState EDOTAGCMsg = 7432 + EDOTAGCMsg_k_EMsgGCToGCSendLeagueAdminState EDOTAGCMsg = 7433 + EDOTAGCMsg_k_EMsgGCLeagueAdminList EDOTAGCMsg = 7434 + EDOTAGCMsg_k_EMsgGCNotificationsMarkReadRequest EDOTAGCMsg = 7435 + EDOTAGCMsg_k_EMsgGCFantasyMessageAdd EDOTAGCMsg = 7436 + EDOTAGCMsg_k_EMsgGCFantasyMessagesRequest EDOTAGCMsg = 7437 + EDOTAGCMsg_k_EMsgGCFantasyMessagesResponse EDOTAGCMsg = 7438 + EDOTAGCMsg_k_EMsgGCFantasyScheduledMatchesRequest EDOTAGCMsg = 7439 + EDOTAGCMsg_k_EMsgGCFantasyScheduledMatchesResponse EDOTAGCMsg = 7440 + EDOTAGCMsg_k_EMsgGCToGCGrantLeagueAccess EDOTAGCMsg = 7441 + EDOTAGCMsg_k_EMsgGCEventGameCreate EDOTAGCMsg = 7443 + EDOTAGCMsg_k_EMsgGCPerfectWorldUserLookupRequest EDOTAGCMsg = 7444 + EDOTAGCMsg_k_EMsgGCPerfectWorldUserLookupResponse EDOTAGCMsg = 7445 + EDOTAGCMsg_k_EMsgGCToGCIncrementRecruitmentSDO EDOTAGCMsg = 7446 + EDOTAGCMsg_k_EMsgGCToGCIncrementRecruitmentLevel EDOTAGCMsg = 7447 + EDOTAGCMsg_k_EMsgGCFantasyRemoveOwner EDOTAGCMsg = 7448 + EDOTAGCMsg_k_EMsgGCFantasyRemoveOwnerResponse EDOTAGCMsg = 7449 + EDOTAGCMsg_k_EMsgGCRequestBatchPlayerResources EDOTAGCMsg = 7450 + EDOTAGCMsg_k_EMsgGCRequestBatchPlayerResourcesResponse EDOTAGCMsg = 7451 + EDOTAGCMsg_k_EMsgGCToGCSendUpdateLeagues EDOTAGCMsg = 7452 + EDOTAGCMsg_k_EMsgGCCompendiumSetSelectionResponse EDOTAGCMsg = 7453 + EDOTAGCMsg_k_EMsgGCPlayerInfoRequest EDOTAGCMsg = 7454 + EDOTAGCMsg_k_EMsgGCPlayerInfo EDOTAGCMsg = 7455 + EDOTAGCMsg_k_EMsgGCPlayerInfoSubmit EDOTAGCMsg = 7456 + EDOTAGCMsg_k_EMsgGCPlayerInfoSubmitResponse EDOTAGCMsg = 7457 + EDOTAGCMsg_k_EMsgGCToGCGetAccountLevel EDOTAGCMsg = 7458 + EDOTAGCMsg_k_EMsgGCToGCGetAccountLevelResponse EDOTAGCMsg = 7459 + EDOTAGCMsg_k_EMsgGCToGCGetAccountPartner EDOTAGCMsg = 7460 + EDOTAGCMsg_k_EMsgGCToGCGetAccountPartnerResponse EDOTAGCMsg = 7461 + EDOTAGCMsg_k_EMsgGCToGCGetAccountProfile EDOTAGCMsg = 7462 + EDOTAGCMsg_k_EMsgGCToGCGetAccountProfileResponse EDOTAGCMsg = 7463 + EDOTAGCMsg_k_EMsgDOTAGetWeekendTourneySchedule EDOTAGCMsg = 7464 + EDOTAGCMsg_k_EMsgDOTAWeekendTourneySchedule EDOTAGCMsg = 7465 + EDOTAGCMsg_k_EMsgGCJoinableCustomGameModesRequest EDOTAGCMsg = 7466 + EDOTAGCMsg_k_EMsgGCJoinableCustomGameModesResponse EDOTAGCMsg = 7467 + EDOTAGCMsg_k_EMsgGCJoinableCustomLobbiesRequest EDOTAGCMsg = 7468 + EDOTAGCMsg_k_EMsgGCJoinableCustomLobbiesResponse EDOTAGCMsg = 7469 + EDOTAGCMsg_k_EMsgGCQuickJoinCustomLobby EDOTAGCMsg = 7470 + EDOTAGCMsg_k_EMsgGCQuickJoinCustomLobbyResponse EDOTAGCMsg = 7471 + EDOTAGCMsg_k_EMsgGCToGCGrantEventPointAction EDOTAGCMsg = 7472 + EDOTAGCMsg_k_EMsgServerGetEventPoints EDOTAGCMsg = 7473 + EDOTAGCMsg_k_EMsgServerGetEventPointsResponse EDOTAGCMsg = 7474 + EDOTAGCMsg_k_EMsgServerGrantSurveyPermission EDOTAGCMsg = 7475 + EDOTAGCMsg_k_EMsgServerGrantSurveyPermissionResponse EDOTAGCMsg = 7476 + EDOTAGCMsg_k_EMsgClientProvideSurveyResult EDOTAGCMsg = 7477 + EDOTAGCMsg_k_EMsgGCToGCSetCompendiumSelection EDOTAGCMsg = 7478 + EDOTAGCMsg_k_EMsgGCToGCUpdateTI4HeroQuest EDOTAGCMsg = 7480 + EDOTAGCMsg_k_EMsgGCCompendiumDataChanged EDOTAGCMsg = 7481 + EDOTAGCMsg_k_EMsgDOTAFantasyLeagueFindRequest EDOTAGCMsg = 7482 + EDOTAGCMsg_k_EMsgDOTAFantasyLeagueFindResponse EDOTAGCMsg = 7483 + EDOTAGCMsg_k_EMsgGCHasItemQuery EDOTAGCMsg = 7484 + EDOTAGCMsg_k_EMsgGCHasItemResponse EDOTAGCMsg = 7485 + EDOTAGCMsg_k_EMsgGCConsumeFantasyTicket EDOTAGCMsg = 7486 + EDOTAGCMsg_k_EMsgGCConsumeFantasyTicketFailure EDOTAGCMsg = 7487 + EDOTAGCMsg_k_EMsgGCToGCGrantEventPointActionMsg EDOTAGCMsg = 7488 + EDOTAGCMsg_k_EMsgClientToGCTrackDialogResult EDOTAGCMsg = 7489 + EDOTAGCMsg_k_EMsgGCFantasyLeaveLeagueRequest EDOTAGCMsg = 7490 + EDOTAGCMsg_k_EMsgGCFantasyLeaveLeagueResponse EDOTAGCMsg = 7491 + EDOTAGCMsg_k_EMsgGCToGCGetCompendiumSelections EDOTAGCMsg = 7492 + EDOTAGCMsg_k_EMsgGCToGCGetCompendiumSelectionsResponse EDOTAGCMsg = 7493 + EDOTAGCMsg_k_EMsgServerToGCMatchConnectionStats EDOTAGCMsg = 7494 + EDOTAGCMsg_k_EMsgGCToClientTournamentItemDrop EDOTAGCMsg = 7495 + EDOTAGCMsg_k_EMsgSQLDelayedGrantLeagueDrop EDOTAGCMsg = 7496 + EDOTAGCMsg_k_EMsgServerGCUpdateSpectatorCount EDOTAGCMsg = 7497 + EDOTAGCMsg_k_EMsgDOTAStartDailyHeroChallengeRequest EDOTAGCMsg = 7498 + EDOTAGCMsg_k_EMsgGCFantasyPlayerScoreDetailsRequest EDOTAGCMsg = 7499 + EDOTAGCMsg_k_EMsgGCFantasyPlayerScoreDetailsResponse EDOTAGCMsg = 7500 + EDOTAGCMsg_k_EMsgGCToGCEmoticonUnlock EDOTAGCMsg = 7501 + EDOTAGCMsg_k_EMsgSignOutDraftInfo EDOTAGCMsg = 7502 + EDOTAGCMsg_k_EMsgClientToGCEmoticonDataRequest EDOTAGCMsg = 7503 + EDOTAGCMsg_k_EMsgGCToClientEmoticonData EDOTAGCMsg = 7504 + EDOTAGCMsg_k_EMsgGCPracticeLobbyToggleBroadcastChannelCameramanStatus EDOTAGCMsg = 7505 + EDOTAGCMsg_k_EMsgGCToGCCreateWeekendTourneyRequest EDOTAGCMsg = 7506 + EDOTAGCMsg_k_EMsgGCToGCCreateWeekendTourneyResponse EDOTAGCMsg = 7507 + EDOTAGCMsg_k_EMsgGCToGCCreateGenericTeamsRequest EDOTAGCMsg = 7510 + EDOTAGCMsg_k_EMsgGCToGCCreateGenericTeamsResponse EDOTAGCMsg = 7511 + EDOTAGCMsg_k_EMsgSQLLaunchOneWeekendTourney EDOTAGCMsg = 7512 + EDOTAGCMsg_k_EMsgClientToGCSetAdditionalEquips EDOTAGCMsg = 7513 + EDOTAGCMsg_k_EMsgClientToGCGetAdditionalEquips EDOTAGCMsg = 7514 + EDOTAGCMsg_k_EMsgClientToGCGetAdditionalEquipsResponse EDOTAGCMsg = 7515 + EDOTAGCMsg_k_EMsgServerToGCGetAdditionalEquips EDOTAGCMsg = 7516 + EDOTAGCMsg_k_EMsgServerToGCGetAdditionalEquipsResponse EDOTAGCMsg = 7517 + EDOTAGCMsg_k_EMsgDOTARedeemItem EDOTAGCMsg = 7518 + EDOTAGCMsg_k_EMsgDOTARedeemItemResponse EDOTAGCMsg = 7519 + EDOTAGCMsg_k_EMsgSQLGCToGCGrantAllHeroProgress EDOTAGCMsg = 7520 + EDOTAGCMsg_k_EMsgClientToGCGetAllHeroProgress EDOTAGCMsg = 7521 + EDOTAGCMsg_k_EMsgClientToGCGetAllHeroProgressResponse EDOTAGCMsg = 7522 + EDOTAGCMsg_k_EMsgGCToGCGetServerForClient EDOTAGCMsg = 7523 + EDOTAGCMsg_k_EMsgGCToGCGetServerForClientResponse EDOTAGCMsg = 7524 + EDOTAGCMsg_k_EMsgSQLProcessTournamentGameOutcome EDOTAGCMsg = 7525 + EDOTAGCMsg_k_EMsgSQLGrantTrophyToAccount EDOTAGCMsg = 7526 + EDOTAGCMsg_k_EMsgClientToGCGetTrophyList EDOTAGCMsg = 7527 + EDOTAGCMsg_k_EMsgClientToGCGetTrophyListResponse EDOTAGCMsg = 7528 + EDOTAGCMsg_k_EMsgGCToClientTrophyAwarded EDOTAGCMsg = 7529 + EDOTAGCMsg_k_EMsgGCGameBotMatchSignOut EDOTAGCMsg = 7530 + EDOTAGCMsg_k_EMsgGCGameBotMatchSignOutPermissionRequest EDOTAGCMsg = 7531 + EDOTAGCMsg_k_EMsgSignOutBotInfo EDOTAGCMsg = 7532 + EDOTAGCMsg_k_EMsgGCToGCUpdateProfileCards EDOTAGCMsg = 7533 + EDOTAGCMsg_k_EMsgClientToGCGetProfileCard EDOTAGCMsg = 7534 + EDOTAGCMsg_k_EMsgClientToGCGetProfileCardResponse EDOTAGCMsg = 7535 + EDOTAGCMsg_k_EMsgServerToGCGetProfileCard EDOTAGCMsg = 7536 + EDOTAGCMsg_k_EMsgServerToGCGetProfileCardResponse EDOTAGCMsg = 7537 + EDOTAGCMsg_k_EMsgClientToGCSetProfileCardSlots EDOTAGCMsg = 7538 + EDOTAGCMsg_k_EMsgGCToClientProfileCardUpdated EDOTAGCMsg = 7539 + EDOTAGCMsg_k_EMsgServerToGCVictoryPredictions EDOTAGCMsg = 7540 + EDOTAGCMsg_k_EMsgClientToGCMarkNotificationListRead EDOTAGCMsg = 7542 + EDOTAGCMsg_k_EMsgGCToClientNewNotificationAdded EDOTAGCMsg = 7543 + EDOTAGCMsg_k_EMsgServerToGCSuspiciousActivity EDOTAGCMsg = 7544 + EDOTAGCMsg_k_EMsgSignOutCommunicationSummary EDOTAGCMsg = 7545 + EDOTAGCMsg_k_EMsgServerToGCRequestStatus_Response EDOTAGCMsg = 7546 + EDOTAGCMsg_k_EMsgClientToGCCreateHeroStatue EDOTAGCMsg = 7547 + EDOTAGCMsg_k_EMsgGCToClientHeroStatueCreateResult EDOTAGCMsg = 7548 + EDOTAGCMsg_k_EMsgGCGCToLANServerRelayConnect EDOTAGCMsg = 7549 + EDOTAGCMsg_k_EMsgSignOutAssassinMiniGameInfo EDOTAGCMsg = 7550 + EDOTAGCMsg_k_EMsgServerToGCGetIngameEventData EDOTAGCMsg = 7551 + EDOTAGCMsg_k_EMsgGCToGCUpdateIngameEventDataBroadcast EDOTAGCMsg = 7552 + EDOTAGCMsg_k_EMsgGCToServerIngameEventData_OraclePA EDOTAGCMsg = 7553 + EDOTAGCMsg_k_EMsgServerToGCReportKillSummaries EDOTAGCMsg = 7554 + EDOTAGCMsg_k_EMsgGCToGCReportKillSummaries EDOTAGCMsg = 7555 + EDOTAGCMsg_k_EMsgGCToGCUpdateAssassinMinigame EDOTAGCMsg = 7556 + EDOTAGCMsg_k_EMsgGCToGCFantasySetMatchLeague EDOTAGCMsg = 7557 + EDOTAGCMsg_k_EMsgClientToGCRecordCompendiumStats EDOTAGCMsg = 7558 + EDOTAGCMsg_k_EMsgGCItemEditorRequestLeagueInfo EDOTAGCMsg = 7559 + EDOTAGCMsg_k_EMsgGCItemEditorLeagueInfoResponse EDOTAGCMsg = 7560 + EDOTAGCMsg_k_EMsgGCToGCUpdatePlayerPredictions EDOTAGCMsg = 7561 + EDOTAGCMsg_k_EMsgGCToServerPredictionResult EDOTAGCMsg = 7562 + EDOTAGCMsg_k_EMsgServerToGCSignoutAwardAdditionalDrops EDOTAGCMsg = 7563 + EDOTAGCMsg_k_EMsgGCToGCSignoutAwardAdditionalDrops EDOTAGCMsg = 7564 + EDOTAGCMsg_k_EMsgGCToClientEventStatusChanged EDOTAGCMsg = 7565 + EDOTAGCMsg_k_EMsgGCHasItemDefsQuery EDOTAGCMsg = 7566 + EDOTAGCMsg_k_EMsgGCHasItemDefsResponse EDOTAGCMsg = 7567 + EDOTAGCMsg_k_EMsgGCToGCReplayMonitorValidateReplay EDOTAGCMsg = 7569 + EDOTAGCMsg_k_EMsgLobbyEventPoints EDOTAGCMsg = 7572 + EDOTAGCMsg_k_EMsgGCToGCGetCustomGameTickets EDOTAGCMsg = 7573 + EDOTAGCMsg_k_EMsgGCToGCGetCustomGameTicketsResponse EDOTAGCMsg = 7574 + EDOTAGCMsg_k_EMsgGCToClientNewBloomTimingUpdated EDOTAGCMsg = 7575 + EDOTAGCMsg_k_EMsgGCToGCCustomGamePlayed EDOTAGCMsg = 7576 + EDOTAGCMsg_k_EMsgGCToGCGrantEventPointsToUser EDOTAGCMsg = 7577 + EDOTAGCMsg_k_EMsgGCToGCSetEventMMPanicFlushTime EDOTAGCMsg = 7578 + EDOTAGCMsg_k_EMsgGameserverCrashReport EDOTAGCMsg = 7579 + EDOTAGCMsg_k_EMsgGameserverCrashReportResponse EDOTAGCMsg = 7580 + EDOTAGCMsg_k_EMsgGCToClientSteamDatagramTicket EDOTAGCMsg = 7581 + EDOTAGCMsg_k_EMsgGCToGCGrantEventOwnership EDOTAGCMsg = 7582 + EDOTAGCMsg_k_EMsgGCToGCSendAccountsEventPoints EDOTAGCMsg = 7583 + EDOTAGCMsg_k_EMsgClientToGCRerollPlayerChallenge EDOTAGCMsg = 7584 + EDOTAGCMsg_k_EMsgServerToGCRerollPlayerChallenge EDOTAGCMsg = 7585 + EDOTAGCMsg_k_EMsgGCRerollPlayerChallengeResponse EDOTAGCMsg = 7586 + EDOTAGCMsg_k_EMsgSignOutUpdatePlayerChallenge EDOTAGCMsg = 7587 + EDOTAGCMsg_k_EMsgClientToGCSetPartyLeader EDOTAGCMsg = 7588 + EDOTAGCMsg_k_EMsgClientToGCCancelPartyInvites EDOTAGCMsg = 7589 + EDOTAGCMsg_k_EMsgGCToGCMasterReloadAccount EDOTAGCMsg = 7590 + EDOTAGCMsg_k_EMsgSQLGrantLeagueMatchToTicketHolders EDOTAGCMsg = 7592 + EDOTAGCMsg_k_EMsgClientToGCSetAdditionalEquipsResponse EDOTAGCMsg = 7593 + EDOTAGCMsg_k_EMsgGCToGCEmoticonUnlockNoRollback EDOTAGCMsg = 7594 + EDOTAGCMsg_k_EMsgGCToGCGetCompendiumFanfare EDOTAGCMsg = 7595 + EDOTAGCMsg_k_EMsgServerToGCHoldEventPoints EDOTAGCMsg = 7596 + EDOTAGCMsg_k_EMsgSignOutReleaseEventPointHolds EDOTAGCMsg = 7597 + EDOTAGCMsg_k_EMsgGCToGCChatNewUserSession EDOTAGCMsg = 7598 + EDOTAGCMsg_k_EMsgClientToGCGetLeagueSeries EDOTAGCMsg = 7599 + EDOTAGCMsg_k_EMsgClientToGCGetLeagueSeriesResponse EDOTAGCMsg = 7600 + EDOTAGCMsg_k_EMsgSQLGCToGCSignoutUpdateLeagueSchedule EDOTAGCMsg = 7601 + EDOTAGCMsg_k_EMsgGCToServerUpdateBroadcastCheers EDOTAGCMsg = 7602 + EDOTAGCMsg_k_EMsgClientToGCApplyGemCombiner EDOTAGCMsg = 7603 + EDOTAGCMsg_k_EMsgClientToGCCreateStaticRecipe EDOTAGCMsg = 7604 + EDOTAGCMsg_k_EMsgClientToGCCreateStaticRecipeResponse EDOTAGCMsg = 7605 + EDOTAGCMsg_k_EMsgClientToGCGetAllHeroOrder EDOTAGCMsg = 7606 + EDOTAGCMsg_k_EMsgClientToGCGetAllHeroOrderResponse EDOTAGCMsg = 7607 + EDOTAGCMsg_k_EMsgSQLGCToGCGrantBadgePoints EDOTAGCMsg = 7608 + EDOTAGCMsg_k_EMsgGCToGCGetAccountMatchStatus EDOTAGCMsg = 7609 + EDOTAGCMsg_k_EMsgGCToGCGetAccountMatchStatusResponse EDOTAGCMsg = 7610 + EDOTAGCMsg_k_EMsgGCDev_GrantWarKill EDOTAGCMsg = 8001 + EDOTAGCMsg_k_EMsgClientToGCCreateTeamShowcase EDOTAGCMsg = 8002 + EDOTAGCMsg_k_EMsgGCToClientTeamShowcaseCreateResult EDOTAGCMsg = 8003 + EDOTAGCMsg_k_EMsgServerToGCLockCharmTrading EDOTAGCMsg = 8004 + EDOTAGCMsg_k_EMsgDOTACNY2015EventPointUsage EDOTAGCMsg = 8005 + EDOTAGCMsg_k_EMsgClientToGCPlayerStatsRequest EDOTAGCMsg = 8006 + EDOTAGCMsg_k_EMsgGCToClientPlayerStatsResponse EDOTAGCMsg = 8007 + EDOTAGCMsg_k_EMsgGCClearPracticeLobbyTeam EDOTAGCMsg = 8008 + EDOTAGCMsg_k_EMsgClientToGCFindTopSourceTVGames EDOTAGCMsg = 8009 + EDOTAGCMsg_k_EMsgGCToClientFindTopSourceTVGamesResponse EDOTAGCMsg = 8010 + EDOTAGCMsg_k_EMsgGCLobbyList EDOTAGCMsg = 8011 + EDOTAGCMsg_k_EMsgGCLobbyListResponse EDOTAGCMsg = 8012 + EDOTAGCMsg_k_EMsgGCPlayerStatsMatchSignOut EDOTAGCMsg = 8013 + EDOTAGCMsg_k_EMsgClientToGCCustomGamePlayerCountRequest EDOTAGCMsg = 8014 + EDOTAGCMsg_k_EMsgGCToClientCustomGamePlayerCountResponse EDOTAGCMsg = 8015 + EDOTAGCMsg_k_EMsgClientToGCSocialFeedPostCommentRequest EDOTAGCMsg = 8016 + EDOTAGCMsg_k_EMsgGCToClientSocialFeedPostCommentResponse EDOTAGCMsg = 8017 + EDOTAGCMsg_k_EMsgClientToGCCustomGamesFriendsPlayedRequest EDOTAGCMsg = 8018 + EDOTAGCMsg_k_EMsgGCToClientCustomGamesFriendsPlayedResponse EDOTAGCMsg = 8019 + EDOTAGCMsg_k_EMsgClientToGCFriendsPlayedCustomGameRequest EDOTAGCMsg = 8020 + EDOTAGCMsg_k_EMsgGCToClientFriendsPlayedCustomGameResponse EDOTAGCMsg = 8021 + EDOTAGCMsg_k_EMsgClientToGCFeaturedHeroesRequest EDOTAGCMsg = 8022 + EDOTAGCMsg_k_EMsgGCToClientFeaturedHeroesResponse EDOTAGCMsg = 8023 + EDOTAGCMsg_k_EMsgGCTopCustomGamesList EDOTAGCMsg = 8024 + EDOTAGCMsg_k_EMsgClientToGCSocialMatchPostCommentRequest EDOTAGCMsg = 8025 + EDOTAGCMsg_k_EMsgGCToClientSocialMatchPostCommentResponse EDOTAGCMsg = 8026 + EDOTAGCMsg_k_EMsgClientToGCSocialMatchDetailsRequest EDOTAGCMsg = 8027 + EDOTAGCMsg_k_EMsgGCToClientSocialMatchDetailsResponse EDOTAGCMsg = 8028 + EDOTAGCMsg_k_EMsgClientToGCSetPartyOpen EDOTAGCMsg = 8029 + EDOTAGCMsg_k_EMsgClientToGCMergePartyInvite EDOTAGCMsg = 8030 + EDOTAGCMsg_k_EMsgGCToClientMergeGroupInviteReply EDOTAGCMsg = 8031 + EDOTAGCMsg_k_EMsgClientToGCMergePartyResponse EDOTAGCMsg = 8032 + EDOTAGCMsg_k_EMsgGCToClientMergePartyResponseReply EDOTAGCMsg = 8033 + EDOTAGCMsg_k_EMsgClientToGCGetProfileCardStats EDOTAGCMsg = 8034 + EDOTAGCMsg_k_EMsgClientToGCGetProfileCardStatsResponse EDOTAGCMsg = 8035 + EDOTAGCMsg_k_EMsgClientToGCTopLeagueMatchesRequest EDOTAGCMsg = 8036 + EDOTAGCMsg_k_EMsgClientToGCTopFriendMatchesRequest EDOTAGCMsg = 8037 + EDOTAGCMsg_k_EMsgGCToClientProfileCardStatsUpdated EDOTAGCMsg = 8040 + EDOTAGCMsg_k_EMsgServerToGCRealtimeStats EDOTAGCMsg = 8041 + EDOTAGCMsg_k_EMsgGCToServerRealtimeStatsStartStop EDOTAGCMsg = 8042 + EDOTAGCMsg_k_EMsgGCToGCGetServersForClients EDOTAGCMsg = 8045 + EDOTAGCMsg_k_EMsgGCToGCGetServersForClientsResponse EDOTAGCMsg = 8046 + EDOTAGCMsg_k_EMsgGCPracticeLobbyKickFromTeam EDOTAGCMsg = 8047 + EDOTAGCMsg_k_EMsgDOTAChatGetMemberCount EDOTAGCMsg = 8048 + EDOTAGCMsg_k_EMsgDOTAChatGetMemberCountResponse EDOTAGCMsg = 8049 + EDOTAGCMsg_k_EMsgClientToGCSocialFeedPostMessageRequest EDOTAGCMsg = 8050 + EDOTAGCMsg_k_EMsgGCToClientSocialFeedPostMessageResponse EDOTAGCMsg = 8051 + EDOTAGCMsg_k_EMsgCustomGameListenServerStartedLoading EDOTAGCMsg = 8052 + EDOTAGCMsg_k_EMsgCustomGameClientFinishedLoading EDOTAGCMsg = 8053 + EDOTAGCMsg_k_EMsgGCPracticeLobbyCloseBroadcastChannel EDOTAGCMsg = 8054 + EDOTAGCMsg_k_EMsgGCStartFindingMatchResponse EDOTAGCMsg = 8055 + EDOTAGCMsg_k_EMsgSQLGCToGCUpdateHeroMMR EDOTAGCMsg = 8056 + EDOTAGCMsg_k_EMsgSQLGCToGCGrantAccountFlag EDOTAGCMsg = 8057 + EDOTAGCMsg_k_EMsgGCToGCGetAccountFlags EDOTAGCMsg = 8058 + EDOTAGCMsg_k_EMsgGCToGCGetAccountFlagsResponse EDOTAGCMsg = 8059 + EDOTAGCMsg_k_EMsgSignOutWagerStats EDOTAGCMsg = 8060 + EDOTAGCMsg_k_EMsgGCToClientTopLeagueMatchesResponse EDOTAGCMsg = 8061 + EDOTAGCMsg_k_EMsgGCToClientTopFriendMatchesResponse EDOTAGCMsg = 8062 + EDOTAGCMsg_k_EMsgClientToGCMatchesMinimalRequest EDOTAGCMsg = 8063 + EDOTAGCMsg_k_EMsgClientToGCMatchesMinimalResponse EDOTAGCMsg = 8064 + EDOTAGCMsg_k_EMsgGCToGCGetProfileBadgePoints EDOTAGCMsg = 8065 + EDOTAGCMsg_k_EMsgGCToGCGetProfileBadgePointsResponse EDOTAGCMsg = 8066 + EDOTAGCMsg_k_EMsgGCToClientChatRegionsEnabled EDOTAGCMsg = 8067 + EDOTAGCMsg_k_EMsgClientToGCPingData EDOTAGCMsg = 8068 + EDOTAGCMsg_k_EMsgServerToGCMatchDetailsRequest EDOTAGCMsg = 8069 + EDOTAGCMsg_k_EMsgGCToServerMatchDetailsResponse EDOTAGCMsg = 8070 + EDOTAGCMsg_k_EMsgGCToGCEnsureAccountInParty EDOTAGCMsg = 8071 + EDOTAGCMsg_k_EMsgGCToGCEnsureAccountInPartyResponse EDOTAGCMsg = 8072 + EDOTAGCMsg_k_EMsgClientToGCGetProfileTickets EDOTAGCMsg = 8073 + EDOTAGCMsg_k_EMsgClientToGCGetProfileTicketsResponse EDOTAGCMsg = 8074 + EDOTAGCMsg_k_EMsgGCToClientMatchGroupsVersion EDOTAGCMsg = 8075 + EDOTAGCMsg_k_EMsgClientToGCH264Unsupported EDOTAGCMsg = 8076 + EDOTAGCMsg_k_EMsgClientToGCRequestH264Support EDOTAGCMsg = 8077 + EDOTAGCMsg_k_EMsgClientToGCGetQuestProgress EDOTAGCMsg = 8078 + EDOTAGCMsg_k_EMsgClientToGCGetQuestProgressResponse EDOTAGCMsg = 8079 + EDOTAGCMsg_k_EMsgSignOutXPCoins EDOTAGCMsg = 8080 + EDOTAGCMsg_k_EMsgGCToClientMatchSignedOut EDOTAGCMsg = 8081 + EDOTAGCMsg_k_EMsgGCGetHeroStatsHistory EDOTAGCMsg = 8082 + EDOTAGCMsg_k_EMsgGCGetHeroStatsHistoryResponse EDOTAGCMsg = 8083 + EDOTAGCMsg_k_EMsgClientToGCPrivateChatInvite EDOTAGCMsg = 8084 + EDOTAGCMsg_k_EMsgClientToGCPrivateChatKick EDOTAGCMsg = 8088 + EDOTAGCMsg_k_EMsgClientToGCPrivateChatPromote EDOTAGCMsg = 8089 + EDOTAGCMsg_k_EMsgClientToGCPrivateChatDemote EDOTAGCMsg = 8090 + EDOTAGCMsg_k_EMsgGCToClientPrivateChatResponse EDOTAGCMsg = 8091 + EDOTAGCMsg_k_EMsgClientToGCPrivateChatInfoRequest EDOTAGCMsg = 8092 + EDOTAGCMsg_k_EMsgGCToClientPrivateChatInfoResponse EDOTAGCMsg = 8093 + EDOTAGCMsg_k_EMsgClientToGCLatestBehaviorReportRequest EDOTAGCMsg = 8095 + EDOTAGCMsg_k_EMsgClientToGCLatestBehaviorReport EDOTAGCMsg = 8096 +) + +var EDOTAGCMsg_name = map[int32]string{ + 7000: "k_EMsgGCDOTABase", + 7001: "k_EMsgGCGeneralResponse", + 7004: "k_EMsgGCGameMatchSignOut", + 7005: "k_EMsgGCGameMatchSignOutResponse", + 7009: "k_EMsgGCJoinChatChannel", + 7010: "k_EMsgGCJoinChatChannelResponse", + 7013: "k_EMsgGCOtherJoinedChannel", + 7014: "k_EMsgGCOtherLeftChannel", + 7017: "k_EMsgGCMatchHistoryList", + 7026: "k_EMsgServerToGCRequestStatus", + 7027: "k_EMsgGCGetRecentMatches", + 7028: "k_EMsgGCRecentMatchesResponse", + 7033: "k_EMsgGCStartFindingMatch", + 7034: "k_EMsgGCConnectedPlayers", + 7035: "k_EMsgGCAbandonCurrentGame", + 7036: "k_EMsgGCStopFindingMatch", + 7038: "k_EMsgGCPracticeLobbyCreate", + 7040: "k_EMsgGCPracticeLobbyLeave", + 7041: "k_EMsgGCPracticeLobbyLaunch", + 7042: "k_EMsgGCPracticeLobbyList", + 7043: "k_EMsgGCPracticeLobbyListResponse", + 7044: "k_EMsgGCPracticeLobbyJoin", + 7046: "k_EMsgGCPracticeLobbySetDetails", + 7047: "k_EMsgGCPracticeLobbySetTeamSlot", + 7049: "k_EMsgGCInitialQuestionnaireResponse", + 7051: "k_EMsgGCTournamentRequest", + 7052: "k_EMsgGCTournamentResponse", + 7055: "k_EMsgGCPracticeLobbyResponse", + 7056: "k_EMsgGCBroadcastNotification", + 7057: "k_EMsgGCLiveScoreboardUpdate", + 7060: "k_EMsgGCRequestChatChannelList", + 7061: "k_EMsgGCRequestChatChannelListResponse", + 7064: "k_EMsgGCRequestMatches", + 7065: "k_EMsgGCRequestMatchesResponse", + 7068: "k_EMsgGCRequestPlayerResources", + 7069: "k_EMsgGCRequestPlayerResourcesResponse", + 7070: "k_EMsgGCReadyUp", + 7071: "k_EMsgGCKickedFromMatchmakingQueue", + 7072: "k_EMsgGCLeaverDetected", + 7073: "k_EMsgGCSpectateFriendGame", + 7074: "k_EMsgGCSpectateFriendGameResponse", + 7075: "k_EMsgGCPlayerReports", + 7076: "k_EMsgGCReportsRemainingRequest", + 7077: "k_EMsgGCReportsRemainingResponse", + 7078: "k_EMsgGCSubmitPlayerReport", + 7079: "k_EMsgGCSubmitPlayerReportResponse", + 7080: "k_EMsgGCGameChatLog", + 7081: "k_EMsgGCPracticeLobbyKick", + 7082: "k_EMsgGCReportCountsRequest", + 7083: "k_EMsgGCReportCountsResponse", + 7084: "k_EMsgGCRequestSaveGames", + 7085: "k_EMsgGCRequestSaveGamesServer", + 7086: "k_EMsgGCRequestSaveGamesResponse", + 7087: "k_EMsgGCLeaverDetectedResponse", + 7088: "k_EMsgGCPlayerFailedToConnect", + 7089: "k_EMsgGCGCToRelayConnect", + 7090: "k_EMsgGCGCToRelayConnectresponse", + 7091: "k_EMsgGCWatchGame", + 7092: "k_EMsgGCWatchGameResponse", + 7093: "k_EMsgGCBanStatusRequest", + 7094: "k_EMsgGCBanStatusResponse", + 7095: "k_EMsgGCMatchDetailsRequest", + 7096: "k_EMsgGCMatchDetailsResponse", + 7097: "k_EMsgGCCancelWatchGame", + 7098: "k_EMsgGCProfileRequest", + 7099: "k_EMsgGCProfileResponse", + 7102: "k_EMsgGCPopup", + 7104: "k_EMsgGCDOTAClearNotifySuccessfulReport", + 7111: "k_EMsgGCFriendPracticeLobbyListRequest", + 7112: "k_EMsgGCFriendPracticeLobbyListResponse", + 7113: "k_EMsgGCPracticeLobbyJoinResponse", + 7114: "k_EMsgClientEconNotification_Job", + 7115: "k_EMsgGCCreateTeam", + 7116: "k_EMsgGCCreateTeamResponse", + 7117: "k_EMsgGCDisbandTeam", + 7118: "k_EMsgGCDisbandTeamResponse", + 7119: "k_EMsgGCRequestTeamData", + 7120: "k_EMsgGCRequestTeamDataResponse", + 7121: "k_EMsgGCTeamData", + 7122: "k_EMsgGCTeamInvite_InviterToGC", + 7123: "k_EMsgGCTeamInvite_GCImmediateResponseToInviter", + 7124: "k_EMsgGCTeamInvite_GCRequestToInvitee", + 7125: "k_EMsgGCTeamInvite_InviteeResponseToGC", + 7126: "k_EMsgGCTeamInvite_GCResponseToInviter", + 7127: "k_EMsgGCTeamInvite_GCResponseToInvitee", + 7128: "k_EMsgGCKickTeamMember", + 7129: "k_EMsgGCKickTeamMemberResponse", + 7130: "k_EMsgGCLeaveTeam", + 7131: "k_EMsgGCLeaveTeamResponse", + 7132: "k_EMsgGCSuggestTeamMatchmaking", + 7133: "k_EMsgGCPlayerHeroesFavoritesAdd", + 7134: "k_EMsgGCPlayerHeroesFavoritesRemove", + 7139: "k_EMsgGCEditTeamLogo", + 7140: "k_EMsgGCEditTeamLogoResponse", + 7141: "k_EMsgGCSetShowcaseHero", + 7142: "k_EMsgGCApplyTeamToPracticeLobby", + 7143: "k_EMsgGCRequestInternatinalTicketEmail", + 7144: "k_EMsgGCTransferTeamAdmin", + 7145: "k_EMsgGCClearTournamentGame", + 7147: "k_EMsgRequestLeagueInfo", + 7148: "k_EMsgResponseLeagueInfo", + 7149: "k_EMsgGCPracticeLobbyJoinBroadcastChannel", + 7150: "k_EMsgGC_TournamentItemEvent", + 7151: "k_EMsgGC_TournamentItemEventResponse", + 7152: "k_EMsgCastMatchVote", + 7153: "k_EMsgCastMatchVoteResponse", + 7154: "k_EMsgRetrieveMatchVote", + 7155: "k_EMsgRetrieveMatchVoteResponse", + 7156: "k_EMsgTeamFanfare", + 7157: "k_EMsgResponseTeamFanfare", + 7158: "k_EMsgGC_GameServerUploadSaveGame", + 7159: "k_EMsgGC_GameServerSaveGameResult", + 7160: "k_EMsgGC_GameServerGetLoadGame", + 7161: "k_EMsgGC_GameServerGetLoadGameResult", + 7164: "k_EMsgGCTeamProfileRequest", + 7165: "k_EMsgGCTeamProfileResponse", + 7166: "k_EMsgGCEditTeamDetails", + 7167: "k_EMsgGCEditTeamDetailsResponse", + 7168: "k_EMsgGCProTeamListRequest", + 7169: "k_EMsgGCProTeamListResponse", + 7170: "k_EMsgGCReadyUpStatus", + 7171: "k_EMsgGCHallOfFame", + 7172: "k_EMsgGCHallOfFameRequest", + 7173: "k_EMsgGCHallOfFameResponse", + 7174: "k_EMsgGCGenerateDiretidePrizeList", + 7176: "k_EMsgGCRewardDiretidePrizes", + 7177: "k_EMsgGCDiretidePrizesRewardedResponse", + 7178: "k_EMsgGCHalloweenHighScoreRequest", + 7179: "k_EMsgGCHalloweenHighScoreResponse", + 7180: "k_EMsgGCGenerateDiretidePrizeListResponse", + 7182: "k_EMsgGCStorePromoPagesRequest", + 7183: "k_EMsgGCStorePromoPagesResponse", + 7184: "k_EMsgGCSpawnLootGreevil", + 7185: "k_EMsgGCDismissLootGreevil", + 7186: "k_EMsgGCToGCMatchCompleted", + 7187: "k_EMsgGCDismissLootGreevilResponse", + 7188: "k_EMsgGCBalancedShuffleLobby", + 7189: "k_EMsgGCToGCCheckLeaguePermission", + 7190: "k_EMsgGCToGCCheckLeaguePermissionResponse", + 7191: "k_EMsgGCLeagueScheduleRequest", + 7192: "k_EMsgGCLeagueScheduleResponse", + 7193: "k_EMsgGCLeagueScheduleEdit", + 7194: "k_EMsgGCLeagueScheduleEditResponse", + 7195: "k_EMsgGCLeaguesInMonthRequest", + 7196: "k_EMsgGCLeaguesInMonthResponse", + 7197: "k_EMsgGCMatchmakingStatsRequest", + 7198: "k_EMsgGCMatchmakingStatsResponse", + 7199: "k_EMsgGCBotGameCreate", + 7200: "k_EMsgGCSetMatchHistoryAccess", + 7201: "k_EMsgGCSetMatchHistoryAccessResponse", + 7203: "k_EMsgUpgradeLeagueItem", + 7204: "k_EMsgUpgradeLeagueItemResponse", + 7205: "k_EMsgGCTeamMemberProfileRequest", + 7206: "k_EMsgGCWatchDownloadedReplay", + 7207: "k_EMsgGCSetMapLocationState", + 7208: "k_EMsgGCSetMapLocationStateResponse", + 7209: "k_EMsgGCResetMapLocations", + 7210: "k_EMsgGCResetMapLocationsResponse", + 7211: "k_EMsgGCTeamOnProfile", + 7212: "k_EMsgGCSetFeaturedItems", + 7215: "k_EMsgGCFeaturedItems", + 7216: "k_EMsgRefreshPartnerAccountLink", + 7217: "k_EMsgClientsRejoinChatChannels", + 7218: "k_EMsgGCToGCGetUserChatInfo", + 7219: "k_EMsgGCToGCGetUserChatInfoResponse", + 7220: "k_EMsgGCToGCLeaveAllChatChannels", + 7221: "k_EMsgGCToGCUpdateAccountChatBan", + 7222: "k_EMsgGCGuildCreateRequest", + 7223: "k_EMsgGCGuildCreateResponse", + 7224: "k_EMsgGCGuildSetAccountRoleRequest", + 7225: "k_EMsgGCGuildSetAccountRoleResponse", + 7226: "k_EMsgGCRequestGuildData", + 7227: "k_EMsgGCGuildData", + 7228: "k_EMsgGCGuildInviteAccountRequest", + 7229: "k_EMsgGCGuildInviteAccountResponse", + 7230: "k_EMsgGCGuildCancelInviteRequest", + 7231: "k_EMsgGCGuildCancelInviteResponse", + 7232: "k_EMsgGCGuildUpdateDetailsRequest", + 7233: "k_EMsgGCGuildUpdateDetailsResponse", + 7234: "k_EMsgGCToGCCanInviteUser", + 7235: "k_EMsgGCToGCCanInviteUserResponse", + 7236: "k_EMsgGCToGCGetUserRank", + 7237: "k_EMsgGCToGCGetUserRankResponse", + 7240: "k_EMsgGCToGCUpdateTeamStats", + 7241: "k_EMsgGCToGCGetTeamRank", + 7242: "k_EMsgGCToGCGetTeamRankResponse", + 7245: "k_EMsgGCTeamIDByNameRequest", + 7246: "k_EMsgGCTeamIDByNameResponse", + 7247: "k_EMsgGCEditTeam", + 7248: "k_EMsgGCPassportDataRequest", + 7249: "k_EMsgGCPassportDataResponse", + 7251: "k_EMsgGCNotInGuildData", + 7254: "k_EMsgGCGuildInviteData", + 7255: "k_EMsgGCToGCGetLeagueAdmin", + 7256: "k_EMsgGCToGCGetLeagueAdminResponse", + 7258: "k_EMsgGCRequestLeaguePrizePool", + 7259: "k_EMsgGCRequestLeaguePrizePoolResponse", + 7261: "k_EMsgGCToGCUpdateOpenGuildPartyRequest", + 7262: "k_EMsgGCToGCUpdateOpenGuildPartyResponse", + 7263: "k_EMsgGCToGCDestroyOpenGuildPartyRequest", + 7264: "k_EMsgGCToGCDestroyOpenGuildPartyResponse", + 7265: "k_EMsgGCGuildUpdateMessage", + 7266: "k_EMsgGCPartySetOpenGuildRequest", + 7267: "k_EMsgGCPartySetOpenGuildResponse", + 7268: "k_EMsgGCGuildOpenPartyRefresh", + 7269: "k_EMsgGCJoinOpenGuildPartyRequest", + 7270: "k_EMsgGCJoinOpenGuildPartyResponse", + 7272: "k_EMsgGCLeaveChatChannel", + 7273: "k_EMsgGCChatMessage", + 7274: "k_EMsgGCGetHeroStandings", + 7275: "k_EMsgGCGetHeroStandingsResponse", + 7279: "k_EMsgGCGuildEditLogoRequest", + 7280: "k_EMsgGCGuildEditLogoResponse", + 7281: "k_EMsgGCGuildmatePracticeLobbyListRequest", + 7282: "k_EMsgGCGuildmatePracticeLobbyListResponse", + 7283: "k_EMsgGCItemEditorReservationsRequest", + 7284: "k_EMsgGCItemEditorReservationsResponse", + 7285: "k_EMsgGCItemEditorReserveItemDef", + 7286: "k_EMsgGCItemEditorReserveItemDefResponse", + 7287: "k_EMsgGCItemEditorReleaseReservation", + 7288: "k_EMsgGCItemEditorReleaseReservationResponse", + 7289: "k_EMsgGCRewardTutorialPrizes", + 7290: "k_EMsgGCLastHitChallengeHighScorePost", + 7291: "k_EMsgGCLastHitChallengeHighScoreRequest", + 7292: "k_EMsgGCLastHitChallengeHighScoreResponse", + 7293: "k_EMsgGCCreateFantasyLeagueRequest", + 7294: "k_EMsgGCCreateFantasyLeagueResponse", + 7297: "k_EMsgGCFantasyLeagueInfoRequest", + 7298: "k_EMsgGCFantasyLeagueInfoResponse", + 7299: "k_EMsgGCFantasyLeagueInfo", + 7300: "k_EMsgGCCreateFantasyTeamRequest", + 7301: "k_EMsgGCCreateFantasyTeamResponse", + 7302: "k_EMsgGCEditFantasyTeamRequest", + 7303: "k_EMsgGCEditFantasyTeamResponse", + 7304: "k_EMsgGCFantasyTeamInfoRequestByFantasyLeagueID", + 7305: "k_EMsgGCFantasyTeamInfoRequestByOwnerAccountID", + 7306: "k_EMsgGCFantasyTeamInfoResponse", + 7307: "k_EMsgGCFantasyTeamInfo", + 7308: "k_EMsgGCFantasyLivePlayerStats", + 7309: "k_EMsgGCFantasyFinalPlayerStats", + 7310: "k_EMsgGCFantasyMatch", + 7311: "k_EMsgGCToGCReloadVersions", + 7312: "k_EMsgGCFantasyTeamScoreRequest", + 7313: "k_EMsgGCFantasyTeamScoreResponse", + 7314: "k_EMsgGCFantasyTeamStandingsRequest", + 7315: "k_EMsgGCFantasyTeamStandingsResponse", + 7316: "k_EMsgGCFantasyPlayerScoreRequest", + 7317: "k_EMsgGCFantasyPlayerScoreResponse", + 7318: "k_EMsgGCFantasyPlayerStandingsRequest", + 7319: "k_EMsgGCFantasyPlayerStandingsResponse", + 7320: "k_EMsgGCFlipLobbyTeams", + 7321: "k_EMsgGCCustomGameCreate", + 7322: "k_EMsgGCFantasyPlayerInfoRequest", + 7323: "k_EMsgGCFantasyPlayerInfoResponse", + 7324: "k_EMsgGCToGCProcessPlayerReportForTarget", + 7325: "k_EMsgGCToGCProcessReportSuccess", + 7326: "k_EMsgGCNotifyAccountFlagsChange", + 7327: "k_EMsgGCSetProfilePrivacy", + 7328: "k_EMsgGCSetProfilePrivacyResponse", + 7329: "k_EMsgGCSteamProfileRequest", + 7330: "k_EMsgGCSteamProfileRequestResponse", + 7331: "k_EMsgGCFantasyLeagueCreateInfoRequest", + 7332: "k_EMsgGCFantasyLeagueCreateInfoResponse", + 7333: "k_EMsgGCFantasyLeagueInviteInfoRequest", + 7334: "k_EMsgGCFantasyLeagueInviteInfoResponse", + 7335: "k_EMsgGCClientIgnoredUser", + 7336: "k_EMsgGCFantasyLeagueCreateRequest", + 7337: "k_EMsgGCFantasyLeagueCreateResponse", + 7338: "k_EMsgGCFantasyTeamCreateRequest", + 7339: "k_EMsgGCFantasyTeamCreateResponse", + 7340: "k_EMsgGCFantasyLeagueFriendJoinListRequest", + 7341: "k_EMsgGCFantasyLeagueFriendJoinListResponse", + 7342: "k_EMsgGCClientSuspended", + 7343: "k_EMsgGCPartyMemberSetCoach", + 7344: "k_EMsgGCFantasyLeagueEditInvitesRequest", + 7345: "k_EMsgGCFantasyLeagueEditInvitesResponse", + 7346: "k_EMsgGCPracticeLobbySetCoach", + 7347: "k_EMsgGCFantasyLeagueEditInfoRequest", + 7348: "k_EMsgGCFantasyLeagueEditInfoResponse", + 7349: "k_EMsgGCFantasyLeagueDraftStatusRequest", + 7350: "k_EMsgGCFantasyLeagueDraftStatus", + 7351: "k_EMsgGCFantasyLeagueDraftPlayerRequest", + 7352: "k_EMsgGCFantasyLeagueDraftPlayerResponse", + 7353: "k_EMsgGCFantasyLeagueMatchupsRequest", + 7354: "k_EMsgGCFantasyLeagueMatchupsResponse", + 7355: "k_EMsgGCFantasyTeamRosterSwapRequest", + 7356: "k_EMsgGCFantasyTeamRosterSwapResponse", + 7357: "k_EMsgGCFantasyTeamRosterRequest", + 7358: "k_EMsgGCFantasyTeamRosterResponse", + 7359: "k_EMsgGCNexonPartnerUpdate", + 7360: "k_EMsgGCToGCProcessPCBangRewardPoints", + 7361: "k_EMsgGCFantasyTeamRosterAddDropRequest", + 7362: "k_EMsgGCFantasyTeamRosterAddDropResponse", + 7363: "k_EMsgPresentedClientTerminateDlg", + 7364: "k_EMsgGCFantasyPlayerHisoricalStatsRequest", + 7365: "k_EMsgGCFantasyPlayerHisoricalStatsResponse", + 7366: "k_EMsgGCPCBangTimedRewardMessage", + 7367: "k_EMsgGCLobbyUpdateBroadcastChannelInfo", + 7368: "k_EMsgGCFantasyTeamTradesRequest", + 7369: "k_EMsgGCFantasyTeamTradesResponse", + 7370: "k_EMsgGCFantasyTeamTradeCancelRequest", + 7371: "k_EMsgGCFantasyTeamTradeCancelResponse", + 7372: "k_EMsgGCToGCGrantTournamentItem", + 7373: "k_EMsgGCProcessFantasyScheduledEvent", + 7374: "k_EMsgGCToGCGrantPCBangRewardItem", + 7375: "k_EMsgGCToGCUpgradeTwitchViewerItems", + 7376: "k_EMsgGCToGCGetLiveMatchAffiliates", + 7377: "k_EMsgGCToGCGetLiveMatchAffiliatesResponse", + 7378: "k_EMsgGCToGCUpdatePlayerPennantCounts", + 7379: "k_EMsgGCToGCGetPlayerPennantCounts", + 7380: "k_EMsgGCToGCGetPlayerPennantCountsResponse", + 7381: "k_EMsgGCGameMatchSignOutPermissionRequest", + 7382: "k_EMsgGCGameMatchSignOutPermissionResponse", + 7383: "k_EMsgDOTAChatChannelMemberUpdate", + 7384: "k_EMsgDOTAAwardEventPoints", + 7385: "k_EMsgDOTARedeemEventPrize", + 7386: "k_EMsgDOTARedeemEventPrizeResponse", + 7387: "k_EMsgDOTAGetEventPoints", + 7388: "k_EMsgDOTAGetEventPointsResponse", + 7390: "k_EMsgGCToGCSignoutAwardEventPoints", + 7393: "k_EMsgDOTASendFriendRecruits", + 7394: "k_EMsgDOTAFriendRecruitsRequest", + 7395: "k_EMsgDOTAFriendRecruitsResponse", + 7396: "k_EMsgDOTAFriendRecruitInviteAcceptDecline", + 7397: "k_EMsgGCPartyLeaderWatchGamePrompt", + 7398: "k_EMsgDOTAFrostivusTimeElapsed", + 7399: "k_EMsgGCToGCGrantEarnedLicense", + 7402: "k_EMsgDOTALiveLeagueGameUpdate", + 7403: "k_EMsgDOTAChatGetUserList", + 7404: "k_EMsgDOTAChatGetUserListResponse", + 7405: "k_EMsgGCCompendiumSetSelection", + 7406: "k_EMsgGCCompendiumDataRequest", + 7407: "k_EMsgGCCompendiumDataResponse", + 7408: "k_EMsgDOTAGetPlayerMatchHistory", + 7409: "k_EMsgDOTAGetPlayerMatchHistoryResponse", + 7410: "k_EMsgGCToGCMatchmakingAddParty", + 7411: "k_EMsgGCToGCMatchmakingRemoveParty", + 7412: "k_EMsgGCToGCMatchmakingRemoveAllParties", + 7413: "k_EMsgGCToGCMatchmakingMatchFound", + 7414: "k_EMsgGCToGCUpdateMatchManagementStats", + 7415: "k_EMsgGCToGCUpdateMatchmakingStats", + 7416: "k_EMsgGCToServerPingRequest", + 7417: "k_EMsgGCToServerPingResponse", + 7418: "k_EMsgGCToServerConsoleCommand", + 7420: "k_EMsgGCToGCUpdateLiveLeagueGameInfo", + 7423: "k_EMsgGCMakeOffering", + 7424: "k_EMsgGCRequestOfferings", + 7425: "k_EMsgGCRequestOfferingsResponse", + 7426: "k_EMsgGCToGCProcessMatchLeaver", + 7427: "k_EMsgGCNotificationsRequest", + 7428: "k_EMsgGCNotificationsResponse", + 7429: "k_EMsgGCToGCModifyNotification", + 7430: "k_EMsgGCToGCSetNewNotifications", + 7431: "k_EMsgGCToGCSetIsLeagueAdmin", + 7432: "k_EMsgGCLeagueAdminState", + 7433: "k_EMsgGCToGCSendLeagueAdminState", + 7434: "k_EMsgGCLeagueAdminList", + 7435: "k_EMsgGCNotificationsMarkReadRequest", + 7436: "k_EMsgGCFantasyMessageAdd", + 7437: "k_EMsgGCFantasyMessagesRequest", + 7438: "k_EMsgGCFantasyMessagesResponse", + 7439: "k_EMsgGCFantasyScheduledMatchesRequest", + 7440: "k_EMsgGCFantasyScheduledMatchesResponse", + 7441: "k_EMsgGCToGCGrantLeagueAccess", + 7443: "k_EMsgGCEventGameCreate", + 7444: "k_EMsgGCPerfectWorldUserLookupRequest", + 7445: "k_EMsgGCPerfectWorldUserLookupResponse", + 7446: "k_EMsgGCToGCIncrementRecruitmentSDO", + 7447: "k_EMsgGCToGCIncrementRecruitmentLevel", + 7448: "k_EMsgGCFantasyRemoveOwner", + 7449: "k_EMsgGCFantasyRemoveOwnerResponse", + 7450: "k_EMsgGCRequestBatchPlayerResources", + 7451: "k_EMsgGCRequestBatchPlayerResourcesResponse", + 7452: "k_EMsgGCToGCSendUpdateLeagues", + 7453: "k_EMsgGCCompendiumSetSelectionResponse", + 7454: "k_EMsgGCPlayerInfoRequest", + 7455: "k_EMsgGCPlayerInfo", + 7456: "k_EMsgGCPlayerInfoSubmit", + 7457: "k_EMsgGCPlayerInfoSubmitResponse", + 7458: "k_EMsgGCToGCGetAccountLevel", + 7459: "k_EMsgGCToGCGetAccountLevelResponse", + 7460: "k_EMsgGCToGCGetAccountPartner", + 7461: "k_EMsgGCToGCGetAccountPartnerResponse", + 7462: "k_EMsgGCToGCGetAccountProfile", + 7463: "k_EMsgGCToGCGetAccountProfileResponse", + 7464: "k_EMsgDOTAGetWeekendTourneySchedule", + 7465: "k_EMsgDOTAWeekendTourneySchedule", + 7466: "k_EMsgGCJoinableCustomGameModesRequest", + 7467: "k_EMsgGCJoinableCustomGameModesResponse", + 7468: "k_EMsgGCJoinableCustomLobbiesRequest", + 7469: "k_EMsgGCJoinableCustomLobbiesResponse", + 7470: "k_EMsgGCQuickJoinCustomLobby", + 7471: "k_EMsgGCQuickJoinCustomLobbyResponse", + 7472: "k_EMsgGCToGCGrantEventPointAction", + 7473: "k_EMsgServerGetEventPoints", + 7474: "k_EMsgServerGetEventPointsResponse", + 7475: "k_EMsgServerGrantSurveyPermission", + 7476: "k_EMsgServerGrantSurveyPermissionResponse", + 7477: "k_EMsgClientProvideSurveyResult", + 7478: "k_EMsgGCToGCSetCompendiumSelection", + 7480: "k_EMsgGCToGCUpdateTI4HeroQuest", + 7481: "k_EMsgGCCompendiumDataChanged", + 7482: "k_EMsgDOTAFantasyLeagueFindRequest", + 7483: "k_EMsgDOTAFantasyLeagueFindResponse", + 7484: "k_EMsgGCHasItemQuery", + 7485: "k_EMsgGCHasItemResponse", + 7486: "k_EMsgGCConsumeFantasyTicket", + 7487: "k_EMsgGCConsumeFantasyTicketFailure", + 7488: "k_EMsgGCToGCGrantEventPointActionMsg", + 7489: "k_EMsgClientToGCTrackDialogResult", + 7490: "k_EMsgGCFantasyLeaveLeagueRequest", + 7491: "k_EMsgGCFantasyLeaveLeagueResponse", + 7492: "k_EMsgGCToGCGetCompendiumSelections", + 7493: "k_EMsgGCToGCGetCompendiumSelectionsResponse", + 7494: "k_EMsgServerToGCMatchConnectionStats", + 7495: "k_EMsgGCToClientTournamentItemDrop", + 7496: "k_EMsgSQLDelayedGrantLeagueDrop", + 7497: "k_EMsgServerGCUpdateSpectatorCount", + 7498: "k_EMsgDOTAStartDailyHeroChallengeRequest", + 7499: "k_EMsgGCFantasyPlayerScoreDetailsRequest", + 7500: "k_EMsgGCFantasyPlayerScoreDetailsResponse", + 7501: "k_EMsgGCToGCEmoticonUnlock", + 7502: "k_EMsgSignOutDraftInfo", + 7503: "k_EMsgClientToGCEmoticonDataRequest", + 7504: "k_EMsgGCToClientEmoticonData", + 7505: "k_EMsgGCPracticeLobbyToggleBroadcastChannelCameramanStatus", + 7506: "k_EMsgGCToGCCreateWeekendTourneyRequest", + 7507: "k_EMsgGCToGCCreateWeekendTourneyResponse", + 7510: "k_EMsgGCToGCCreateGenericTeamsRequest", + 7511: "k_EMsgGCToGCCreateGenericTeamsResponse", + 7512: "k_EMsgSQLLaunchOneWeekendTourney", + 7513: "k_EMsgClientToGCSetAdditionalEquips", + 7514: "k_EMsgClientToGCGetAdditionalEquips", + 7515: "k_EMsgClientToGCGetAdditionalEquipsResponse", + 7516: "k_EMsgServerToGCGetAdditionalEquips", + 7517: "k_EMsgServerToGCGetAdditionalEquipsResponse", + 7518: "k_EMsgDOTARedeemItem", + 7519: "k_EMsgDOTARedeemItemResponse", + 7520: "k_EMsgSQLGCToGCGrantAllHeroProgress", + 7521: "k_EMsgClientToGCGetAllHeroProgress", + 7522: "k_EMsgClientToGCGetAllHeroProgressResponse", + 7523: "k_EMsgGCToGCGetServerForClient", + 7524: "k_EMsgGCToGCGetServerForClientResponse", + 7525: "k_EMsgSQLProcessTournamentGameOutcome", + 7526: "k_EMsgSQLGrantTrophyToAccount", + 7527: "k_EMsgClientToGCGetTrophyList", + 7528: "k_EMsgClientToGCGetTrophyListResponse", + 7529: "k_EMsgGCToClientTrophyAwarded", + 7530: "k_EMsgGCGameBotMatchSignOut", + 7531: "k_EMsgGCGameBotMatchSignOutPermissionRequest", + 7532: "k_EMsgSignOutBotInfo", + 7533: "k_EMsgGCToGCUpdateProfileCards", + 7534: "k_EMsgClientToGCGetProfileCard", + 7535: "k_EMsgClientToGCGetProfileCardResponse", + 7536: "k_EMsgServerToGCGetProfileCard", + 7537: "k_EMsgServerToGCGetProfileCardResponse", + 7538: "k_EMsgClientToGCSetProfileCardSlots", + 7539: "k_EMsgGCToClientProfileCardUpdated", + 7540: "k_EMsgServerToGCVictoryPredictions", + 7542: "k_EMsgClientToGCMarkNotificationListRead", + 7543: "k_EMsgGCToClientNewNotificationAdded", + 7544: "k_EMsgServerToGCSuspiciousActivity", + 7545: "k_EMsgSignOutCommunicationSummary", + 7546: "k_EMsgServerToGCRequestStatus_Response", + 7547: "k_EMsgClientToGCCreateHeroStatue", + 7548: "k_EMsgGCToClientHeroStatueCreateResult", + 7549: "k_EMsgGCGCToLANServerRelayConnect", + 7550: "k_EMsgSignOutAssassinMiniGameInfo", + 7551: "k_EMsgServerToGCGetIngameEventData", + 7552: "k_EMsgGCToGCUpdateIngameEventDataBroadcast", + 7553: "k_EMsgGCToServerIngameEventData_OraclePA", + 7554: "k_EMsgServerToGCReportKillSummaries", + 7555: "k_EMsgGCToGCReportKillSummaries", + 7556: "k_EMsgGCToGCUpdateAssassinMinigame", + 7557: "k_EMsgGCToGCFantasySetMatchLeague", + 7558: "k_EMsgClientToGCRecordCompendiumStats", + 7559: "k_EMsgGCItemEditorRequestLeagueInfo", + 7560: "k_EMsgGCItemEditorLeagueInfoResponse", + 7561: "k_EMsgGCToGCUpdatePlayerPredictions", + 7562: "k_EMsgGCToServerPredictionResult", + 7563: "k_EMsgServerToGCSignoutAwardAdditionalDrops", + 7564: "k_EMsgGCToGCSignoutAwardAdditionalDrops", + 7565: "k_EMsgGCToClientEventStatusChanged", + 7566: "k_EMsgGCHasItemDefsQuery", + 7567: "k_EMsgGCHasItemDefsResponse", + 7569: "k_EMsgGCToGCReplayMonitorValidateReplay", + 7572: "k_EMsgLobbyEventPoints", + 7573: "k_EMsgGCToGCGetCustomGameTickets", + 7574: "k_EMsgGCToGCGetCustomGameTicketsResponse", + 7575: "k_EMsgGCToClientNewBloomTimingUpdated", + 7576: "k_EMsgGCToGCCustomGamePlayed", + 7577: "k_EMsgGCToGCGrantEventPointsToUser", + 7578: "k_EMsgGCToGCSetEventMMPanicFlushTime", + 7579: "k_EMsgGameserverCrashReport", + 7580: "k_EMsgGameserverCrashReportResponse", + 7581: "k_EMsgGCToClientSteamDatagramTicket", + 7582: "k_EMsgGCToGCGrantEventOwnership", + 7583: "k_EMsgGCToGCSendAccountsEventPoints", + 7584: "k_EMsgClientToGCRerollPlayerChallenge", + 7585: "k_EMsgServerToGCRerollPlayerChallenge", + 7586: "k_EMsgGCRerollPlayerChallengeResponse", + 7587: "k_EMsgSignOutUpdatePlayerChallenge", + 7588: "k_EMsgClientToGCSetPartyLeader", + 7589: "k_EMsgClientToGCCancelPartyInvites", + 7590: "k_EMsgGCToGCMasterReloadAccount", + 7592: "k_EMsgSQLGrantLeagueMatchToTicketHolders", + 7593: "k_EMsgClientToGCSetAdditionalEquipsResponse", + 7594: "k_EMsgGCToGCEmoticonUnlockNoRollback", + 7595: "k_EMsgGCToGCGetCompendiumFanfare", + 7596: "k_EMsgServerToGCHoldEventPoints", + 7597: "k_EMsgSignOutReleaseEventPointHolds", + 7598: "k_EMsgGCToGCChatNewUserSession", + 7599: "k_EMsgClientToGCGetLeagueSeries", + 7600: "k_EMsgClientToGCGetLeagueSeriesResponse", + 7601: "k_EMsgSQLGCToGCSignoutUpdateLeagueSchedule", + 7602: "k_EMsgGCToServerUpdateBroadcastCheers", + 7603: "k_EMsgClientToGCApplyGemCombiner", + 7604: "k_EMsgClientToGCCreateStaticRecipe", + 7605: "k_EMsgClientToGCCreateStaticRecipeResponse", + 7606: "k_EMsgClientToGCGetAllHeroOrder", + 7607: "k_EMsgClientToGCGetAllHeroOrderResponse", + 7608: "k_EMsgSQLGCToGCGrantBadgePoints", + 7609: "k_EMsgGCToGCGetAccountMatchStatus", + 7610: "k_EMsgGCToGCGetAccountMatchStatusResponse", + 8001: "k_EMsgGCDev_GrantWarKill", + 8002: "k_EMsgClientToGCCreateTeamShowcase", + 8003: "k_EMsgGCToClientTeamShowcaseCreateResult", + 8004: "k_EMsgServerToGCLockCharmTrading", + 8005: "k_EMsgDOTACNY2015EventPointUsage", + 8006: "k_EMsgClientToGCPlayerStatsRequest", + 8007: "k_EMsgGCToClientPlayerStatsResponse", + 8008: "k_EMsgGCClearPracticeLobbyTeam", + 8009: "k_EMsgClientToGCFindTopSourceTVGames", + 8010: "k_EMsgGCToClientFindTopSourceTVGamesResponse", + 8011: "k_EMsgGCLobbyList", + 8012: "k_EMsgGCLobbyListResponse", + 8013: "k_EMsgGCPlayerStatsMatchSignOut", + 8014: "k_EMsgClientToGCCustomGamePlayerCountRequest", + 8015: "k_EMsgGCToClientCustomGamePlayerCountResponse", + 8016: "k_EMsgClientToGCSocialFeedPostCommentRequest", + 8017: "k_EMsgGCToClientSocialFeedPostCommentResponse", + 8018: "k_EMsgClientToGCCustomGamesFriendsPlayedRequest", + 8019: "k_EMsgGCToClientCustomGamesFriendsPlayedResponse", + 8020: "k_EMsgClientToGCFriendsPlayedCustomGameRequest", + 8021: "k_EMsgGCToClientFriendsPlayedCustomGameResponse", + 8022: "k_EMsgClientToGCFeaturedHeroesRequest", + 8023: "k_EMsgGCToClientFeaturedHeroesResponse", + 8024: "k_EMsgGCTopCustomGamesList", + 8025: "k_EMsgClientToGCSocialMatchPostCommentRequest", + 8026: "k_EMsgGCToClientSocialMatchPostCommentResponse", + 8027: "k_EMsgClientToGCSocialMatchDetailsRequest", + 8028: "k_EMsgGCToClientSocialMatchDetailsResponse", + 8029: "k_EMsgClientToGCSetPartyOpen", + 8030: "k_EMsgClientToGCMergePartyInvite", + 8031: "k_EMsgGCToClientMergeGroupInviteReply", + 8032: "k_EMsgClientToGCMergePartyResponse", + 8033: "k_EMsgGCToClientMergePartyResponseReply", + 8034: "k_EMsgClientToGCGetProfileCardStats", + 8035: "k_EMsgClientToGCGetProfileCardStatsResponse", + 8036: "k_EMsgClientToGCTopLeagueMatchesRequest", + 8037: "k_EMsgClientToGCTopFriendMatchesRequest", + 8040: "k_EMsgGCToClientProfileCardStatsUpdated", + 8041: "k_EMsgServerToGCRealtimeStats", + 8042: "k_EMsgGCToServerRealtimeStatsStartStop", + 8045: "k_EMsgGCToGCGetServersForClients", + 8046: "k_EMsgGCToGCGetServersForClientsResponse", + 8047: "k_EMsgGCPracticeLobbyKickFromTeam", + 8048: "k_EMsgDOTAChatGetMemberCount", + 8049: "k_EMsgDOTAChatGetMemberCountResponse", + 8050: "k_EMsgClientToGCSocialFeedPostMessageRequest", + 8051: "k_EMsgGCToClientSocialFeedPostMessageResponse", + 8052: "k_EMsgCustomGameListenServerStartedLoading", + 8053: "k_EMsgCustomGameClientFinishedLoading", + 8054: "k_EMsgGCPracticeLobbyCloseBroadcastChannel", + 8055: "k_EMsgGCStartFindingMatchResponse", + 8056: "k_EMsgSQLGCToGCUpdateHeroMMR", + 8057: "k_EMsgSQLGCToGCGrantAccountFlag", + 8058: "k_EMsgGCToGCGetAccountFlags", + 8059: "k_EMsgGCToGCGetAccountFlagsResponse", + 8060: "k_EMsgSignOutWagerStats", + 8061: "k_EMsgGCToClientTopLeagueMatchesResponse", + 8062: "k_EMsgGCToClientTopFriendMatchesResponse", + 8063: "k_EMsgClientToGCMatchesMinimalRequest", + 8064: "k_EMsgClientToGCMatchesMinimalResponse", + 8065: "k_EMsgGCToGCGetProfileBadgePoints", + 8066: "k_EMsgGCToGCGetProfileBadgePointsResponse", + 8067: "k_EMsgGCToClientChatRegionsEnabled", + 8068: "k_EMsgClientToGCPingData", + 8069: "k_EMsgServerToGCMatchDetailsRequest", + 8070: "k_EMsgGCToServerMatchDetailsResponse", + 8071: "k_EMsgGCToGCEnsureAccountInParty", + 8072: "k_EMsgGCToGCEnsureAccountInPartyResponse", + 8073: "k_EMsgClientToGCGetProfileTickets", + 8074: "k_EMsgClientToGCGetProfileTicketsResponse", + 8075: "k_EMsgGCToClientMatchGroupsVersion", + 8076: "k_EMsgClientToGCH264Unsupported", + 8077: "k_EMsgClientToGCRequestH264Support", + 8078: "k_EMsgClientToGCGetQuestProgress", + 8079: "k_EMsgClientToGCGetQuestProgressResponse", + 8080: "k_EMsgSignOutXPCoins", + 8081: "k_EMsgGCToClientMatchSignedOut", + 8082: "k_EMsgGCGetHeroStatsHistory", + 8083: "k_EMsgGCGetHeroStatsHistoryResponse", + 8084: "k_EMsgClientToGCPrivateChatInvite", + 8088: "k_EMsgClientToGCPrivateChatKick", + 8089: "k_EMsgClientToGCPrivateChatPromote", + 8090: "k_EMsgClientToGCPrivateChatDemote", + 8091: "k_EMsgGCToClientPrivateChatResponse", + 8092: "k_EMsgClientToGCPrivateChatInfoRequest", + 8093: "k_EMsgGCToClientPrivateChatInfoResponse", + 8095: "k_EMsgClientToGCLatestBehaviorReportRequest", + 8096: "k_EMsgClientToGCLatestBehaviorReport", +} +var EDOTAGCMsg_value = map[string]int32{ + "k_EMsgGCDOTABase": 7000, + "k_EMsgGCGeneralResponse": 7001, + "k_EMsgGCGameMatchSignOut": 7004, + "k_EMsgGCGameMatchSignOutResponse": 7005, + "k_EMsgGCJoinChatChannel": 7009, + "k_EMsgGCJoinChatChannelResponse": 7010, + "k_EMsgGCOtherJoinedChannel": 7013, + "k_EMsgGCOtherLeftChannel": 7014, + "k_EMsgGCMatchHistoryList": 7017, + "k_EMsgServerToGCRequestStatus": 7026, + "k_EMsgGCGetRecentMatches": 7027, + "k_EMsgGCRecentMatchesResponse": 7028, + "k_EMsgGCStartFindingMatch": 7033, + "k_EMsgGCConnectedPlayers": 7034, + "k_EMsgGCAbandonCurrentGame": 7035, + "k_EMsgGCStopFindingMatch": 7036, + "k_EMsgGCPracticeLobbyCreate": 7038, + "k_EMsgGCPracticeLobbyLeave": 7040, + "k_EMsgGCPracticeLobbyLaunch": 7041, + "k_EMsgGCPracticeLobbyList": 7042, + "k_EMsgGCPracticeLobbyListResponse": 7043, + "k_EMsgGCPracticeLobbyJoin": 7044, + "k_EMsgGCPracticeLobbySetDetails": 7046, + "k_EMsgGCPracticeLobbySetTeamSlot": 7047, + "k_EMsgGCInitialQuestionnaireResponse": 7049, + "k_EMsgGCTournamentRequest": 7051, + "k_EMsgGCTournamentResponse": 7052, + "k_EMsgGCPracticeLobbyResponse": 7055, + "k_EMsgGCBroadcastNotification": 7056, + "k_EMsgGCLiveScoreboardUpdate": 7057, + "k_EMsgGCRequestChatChannelList": 7060, + "k_EMsgGCRequestChatChannelListResponse": 7061, + "k_EMsgGCRequestMatches": 7064, + "k_EMsgGCRequestMatchesResponse": 7065, + "k_EMsgGCRequestPlayerResources": 7068, + "k_EMsgGCRequestPlayerResourcesResponse": 7069, + "k_EMsgGCReadyUp": 7070, + "k_EMsgGCKickedFromMatchmakingQueue": 7071, + "k_EMsgGCLeaverDetected": 7072, + "k_EMsgGCSpectateFriendGame": 7073, + "k_EMsgGCSpectateFriendGameResponse": 7074, + "k_EMsgGCPlayerReports": 7075, + "k_EMsgGCReportsRemainingRequest": 7076, + "k_EMsgGCReportsRemainingResponse": 7077, + "k_EMsgGCSubmitPlayerReport": 7078, + "k_EMsgGCSubmitPlayerReportResponse": 7079, + "k_EMsgGCGameChatLog": 7080, + "k_EMsgGCPracticeLobbyKick": 7081, + "k_EMsgGCReportCountsRequest": 7082, + "k_EMsgGCReportCountsResponse": 7083, + "k_EMsgGCRequestSaveGames": 7084, + "k_EMsgGCRequestSaveGamesServer": 7085, + "k_EMsgGCRequestSaveGamesResponse": 7086, + "k_EMsgGCLeaverDetectedResponse": 7087, + "k_EMsgGCPlayerFailedToConnect": 7088, + "k_EMsgGCGCToRelayConnect": 7089, + "k_EMsgGCGCToRelayConnectresponse": 7090, + "k_EMsgGCWatchGame": 7091, + "k_EMsgGCWatchGameResponse": 7092, + "k_EMsgGCBanStatusRequest": 7093, + "k_EMsgGCBanStatusResponse": 7094, + "k_EMsgGCMatchDetailsRequest": 7095, + "k_EMsgGCMatchDetailsResponse": 7096, + "k_EMsgGCCancelWatchGame": 7097, + "k_EMsgGCProfileRequest": 7098, + "k_EMsgGCProfileResponse": 7099, + "k_EMsgGCPopup": 7102, + "k_EMsgGCDOTAClearNotifySuccessfulReport": 7104, + "k_EMsgGCFriendPracticeLobbyListRequest": 7111, + "k_EMsgGCFriendPracticeLobbyListResponse": 7112, + "k_EMsgGCPracticeLobbyJoinResponse": 7113, + "k_EMsgClientEconNotification_Job": 7114, + "k_EMsgGCCreateTeam": 7115, + "k_EMsgGCCreateTeamResponse": 7116, + "k_EMsgGCDisbandTeam": 7117, + "k_EMsgGCDisbandTeamResponse": 7118, + "k_EMsgGCRequestTeamData": 7119, + "k_EMsgGCRequestTeamDataResponse": 7120, + "k_EMsgGCTeamData": 7121, + "k_EMsgGCTeamInvite_InviterToGC": 7122, + "k_EMsgGCTeamInvite_GCImmediateResponseToInviter": 7123, + "k_EMsgGCTeamInvite_GCRequestToInvitee": 7124, + "k_EMsgGCTeamInvite_InviteeResponseToGC": 7125, + "k_EMsgGCTeamInvite_GCResponseToInviter": 7126, + "k_EMsgGCTeamInvite_GCResponseToInvitee": 7127, + "k_EMsgGCKickTeamMember": 7128, + "k_EMsgGCKickTeamMemberResponse": 7129, + "k_EMsgGCLeaveTeam": 7130, + "k_EMsgGCLeaveTeamResponse": 7131, + "k_EMsgGCSuggestTeamMatchmaking": 7132, + "k_EMsgGCPlayerHeroesFavoritesAdd": 7133, + "k_EMsgGCPlayerHeroesFavoritesRemove": 7134, + "k_EMsgGCEditTeamLogo": 7139, + "k_EMsgGCEditTeamLogoResponse": 7140, + "k_EMsgGCSetShowcaseHero": 7141, + "k_EMsgGCApplyTeamToPracticeLobby": 7142, + "k_EMsgGCRequestInternatinalTicketEmail": 7143, + "k_EMsgGCTransferTeamAdmin": 7144, + "k_EMsgGCClearTournamentGame": 7145, + "k_EMsgRequestLeagueInfo": 7147, + "k_EMsgResponseLeagueInfo": 7148, + "k_EMsgGCPracticeLobbyJoinBroadcastChannel": 7149, + "k_EMsgGC_TournamentItemEvent": 7150, + "k_EMsgGC_TournamentItemEventResponse": 7151, + "k_EMsgCastMatchVote": 7152, + "k_EMsgCastMatchVoteResponse": 7153, + "k_EMsgRetrieveMatchVote": 7154, + "k_EMsgRetrieveMatchVoteResponse": 7155, + "k_EMsgTeamFanfare": 7156, + "k_EMsgResponseTeamFanfare": 7157, + "k_EMsgGC_GameServerUploadSaveGame": 7158, + "k_EMsgGC_GameServerSaveGameResult": 7159, + "k_EMsgGC_GameServerGetLoadGame": 7160, + "k_EMsgGC_GameServerGetLoadGameResult": 7161, + "k_EMsgGCTeamProfileRequest": 7164, + "k_EMsgGCTeamProfileResponse": 7165, + "k_EMsgGCEditTeamDetails": 7166, + "k_EMsgGCEditTeamDetailsResponse": 7167, + "k_EMsgGCProTeamListRequest": 7168, + "k_EMsgGCProTeamListResponse": 7169, + "k_EMsgGCReadyUpStatus": 7170, + "k_EMsgGCHallOfFame": 7171, + "k_EMsgGCHallOfFameRequest": 7172, + "k_EMsgGCHallOfFameResponse": 7173, + "k_EMsgGCGenerateDiretidePrizeList": 7174, + "k_EMsgGCRewardDiretidePrizes": 7176, + "k_EMsgGCDiretidePrizesRewardedResponse": 7177, + "k_EMsgGCHalloweenHighScoreRequest": 7178, + "k_EMsgGCHalloweenHighScoreResponse": 7179, + "k_EMsgGCGenerateDiretidePrizeListResponse": 7180, + "k_EMsgGCStorePromoPagesRequest": 7182, + "k_EMsgGCStorePromoPagesResponse": 7183, + "k_EMsgGCSpawnLootGreevil": 7184, + "k_EMsgGCDismissLootGreevil": 7185, + "k_EMsgGCToGCMatchCompleted": 7186, + "k_EMsgGCDismissLootGreevilResponse": 7187, + "k_EMsgGCBalancedShuffleLobby": 7188, + "k_EMsgGCToGCCheckLeaguePermission": 7189, + "k_EMsgGCToGCCheckLeaguePermissionResponse": 7190, + "k_EMsgGCLeagueScheduleRequest": 7191, + "k_EMsgGCLeagueScheduleResponse": 7192, + "k_EMsgGCLeagueScheduleEdit": 7193, + "k_EMsgGCLeagueScheduleEditResponse": 7194, + "k_EMsgGCLeaguesInMonthRequest": 7195, + "k_EMsgGCLeaguesInMonthResponse": 7196, + "k_EMsgGCMatchmakingStatsRequest": 7197, + "k_EMsgGCMatchmakingStatsResponse": 7198, + "k_EMsgGCBotGameCreate": 7199, + "k_EMsgGCSetMatchHistoryAccess": 7200, + "k_EMsgGCSetMatchHistoryAccessResponse": 7201, + "k_EMsgUpgradeLeagueItem": 7203, + "k_EMsgUpgradeLeagueItemResponse": 7204, + "k_EMsgGCTeamMemberProfileRequest": 7205, + "k_EMsgGCWatchDownloadedReplay": 7206, + "k_EMsgGCSetMapLocationState": 7207, + "k_EMsgGCSetMapLocationStateResponse": 7208, + "k_EMsgGCResetMapLocations": 7209, + "k_EMsgGCResetMapLocationsResponse": 7210, + "k_EMsgGCTeamOnProfile": 7211, + "k_EMsgGCSetFeaturedItems": 7212, + "k_EMsgGCFeaturedItems": 7215, + "k_EMsgRefreshPartnerAccountLink": 7216, + "k_EMsgClientsRejoinChatChannels": 7217, + "k_EMsgGCToGCGetUserChatInfo": 7218, + "k_EMsgGCToGCGetUserChatInfoResponse": 7219, + "k_EMsgGCToGCLeaveAllChatChannels": 7220, + "k_EMsgGCToGCUpdateAccountChatBan": 7221, + "k_EMsgGCGuildCreateRequest": 7222, + "k_EMsgGCGuildCreateResponse": 7223, + "k_EMsgGCGuildSetAccountRoleRequest": 7224, + "k_EMsgGCGuildSetAccountRoleResponse": 7225, + "k_EMsgGCRequestGuildData": 7226, + "k_EMsgGCGuildData": 7227, + "k_EMsgGCGuildInviteAccountRequest": 7228, + "k_EMsgGCGuildInviteAccountResponse": 7229, + "k_EMsgGCGuildCancelInviteRequest": 7230, + "k_EMsgGCGuildCancelInviteResponse": 7231, + "k_EMsgGCGuildUpdateDetailsRequest": 7232, + "k_EMsgGCGuildUpdateDetailsResponse": 7233, + "k_EMsgGCToGCCanInviteUser": 7234, + "k_EMsgGCToGCCanInviteUserResponse": 7235, + "k_EMsgGCToGCGetUserRank": 7236, + "k_EMsgGCToGCGetUserRankResponse": 7237, + "k_EMsgGCToGCUpdateTeamStats": 7240, + "k_EMsgGCToGCGetTeamRank": 7241, + "k_EMsgGCToGCGetTeamRankResponse": 7242, + "k_EMsgGCTeamIDByNameRequest": 7245, + "k_EMsgGCTeamIDByNameResponse": 7246, + "k_EMsgGCEditTeam": 7247, + "k_EMsgGCPassportDataRequest": 7248, + "k_EMsgGCPassportDataResponse": 7249, + "k_EMsgGCNotInGuildData": 7251, + "k_EMsgGCGuildInviteData": 7254, + "k_EMsgGCToGCGetLeagueAdmin": 7255, + "k_EMsgGCToGCGetLeagueAdminResponse": 7256, + "k_EMsgGCRequestLeaguePrizePool": 7258, + "k_EMsgGCRequestLeaguePrizePoolResponse": 7259, + "k_EMsgGCToGCUpdateOpenGuildPartyRequest": 7261, + "k_EMsgGCToGCUpdateOpenGuildPartyResponse": 7262, + "k_EMsgGCToGCDestroyOpenGuildPartyRequest": 7263, + "k_EMsgGCToGCDestroyOpenGuildPartyResponse": 7264, + "k_EMsgGCGuildUpdateMessage": 7265, + "k_EMsgGCPartySetOpenGuildRequest": 7266, + "k_EMsgGCPartySetOpenGuildResponse": 7267, + "k_EMsgGCGuildOpenPartyRefresh": 7268, + "k_EMsgGCJoinOpenGuildPartyRequest": 7269, + "k_EMsgGCJoinOpenGuildPartyResponse": 7270, + "k_EMsgGCLeaveChatChannel": 7272, + "k_EMsgGCChatMessage": 7273, + "k_EMsgGCGetHeroStandings": 7274, + "k_EMsgGCGetHeroStandingsResponse": 7275, + "k_EMsgGCGuildEditLogoRequest": 7279, + "k_EMsgGCGuildEditLogoResponse": 7280, + "k_EMsgGCGuildmatePracticeLobbyListRequest": 7281, + "k_EMsgGCGuildmatePracticeLobbyListResponse": 7282, + "k_EMsgGCItemEditorReservationsRequest": 7283, + "k_EMsgGCItemEditorReservationsResponse": 7284, + "k_EMsgGCItemEditorReserveItemDef": 7285, + "k_EMsgGCItemEditorReserveItemDefResponse": 7286, + "k_EMsgGCItemEditorReleaseReservation": 7287, + "k_EMsgGCItemEditorReleaseReservationResponse": 7288, + "k_EMsgGCRewardTutorialPrizes": 7289, + "k_EMsgGCLastHitChallengeHighScorePost": 7290, + "k_EMsgGCLastHitChallengeHighScoreRequest": 7291, + "k_EMsgGCLastHitChallengeHighScoreResponse": 7292, + "k_EMsgGCCreateFantasyLeagueRequest": 7293, + "k_EMsgGCCreateFantasyLeagueResponse": 7294, + "k_EMsgGCFantasyLeagueInfoRequest": 7297, + "k_EMsgGCFantasyLeagueInfoResponse": 7298, + "k_EMsgGCFantasyLeagueInfo": 7299, + "k_EMsgGCCreateFantasyTeamRequest": 7300, + "k_EMsgGCCreateFantasyTeamResponse": 7301, + "k_EMsgGCEditFantasyTeamRequest": 7302, + "k_EMsgGCEditFantasyTeamResponse": 7303, + "k_EMsgGCFantasyTeamInfoRequestByFantasyLeagueID": 7304, + "k_EMsgGCFantasyTeamInfoRequestByOwnerAccountID": 7305, + "k_EMsgGCFantasyTeamInfoResponse": 7306, + "k_EMsgGCFantasyTeamInfo": 7307, + "k_EMsgGCFantasyLivePlayerStats": 7308, + "k_EMsgGCFantasyFinalPlayerStats": 7309, + "k_EMsgGCFantasyMatch": 7310, + "k_EMsgGCToGCReloadVersions": 7311, + "k_EMsgGCFantasyTeamScoreRequest": 7312, + "k_EMsgGCFantasyTeamScoreResponse": 7313, + "k_EMsgGCFantasyTeamStandingsRequest": 7314, + "k_EMsgGCFantasyTeamStandingsResponse": 7315, + "k_EMsgGCFantasyPlayerScoreRequest": 7316, + "k_EMsgGCFantasyPlayerScoreResponse": 7317, + "k_EMsgGCFantasyPlayerStandingsRequest": 7318, + "k_EMsgGCFantasyPlayerStandingsResponse": 7319, + "k_EMsgGCFlipLobbyTeams": 7320, + "k_EMsgGCCustomGameCreate": 7321, + "k_EMsgGCFantasyPlayerInfoRequest": 7322, + "k_EMsgGCFantasyPlayerInfoResponse": 7323, + "k_EMsgGCToGCProcessPlayerReportForTarget": 7324, + "k_EMsgGCToGCProcessReportSuccess": 7325, + "k_EMsgGCNotifyAccountFlagsChange": 7326, + "k_EMsgGCSetProfilePrivacy": 7327, + "k_EMsgGCSetProfilePrivacyResponse": 7328, + "k_EMsgGCSteamProfileRequest": 7329, + "k_EMsgGCSteamProfileRequestResponse": 7330, + "k_EMsgGCFantasyLeagueCreateInfoRequest": 7331, + "k_EMsgGCFantasyLeagueCreateInfoResponse": 7332, + "k_EMsgGCFantasyLeagueInviteInfoRequest": 7333, + "k_EMsgGCFantasyLeagueInviteInfoResponse": 7334, + "k_EMsgGCClientIgnoredUser": 7335, + "k_EMsgGCFantasyLeagueCreateRequest": 7336, + "k_EMsgGCFantasyLeagueCreateResponse": 7337, + "k_EMsgGCFantasyTeamCreateRequest": 7338, + "k_EMsgGCFantasyTeamCreateResponse": 7339, + "k_EMsgGCFantasyLeagueFriendJoinListRequest": 7340, + "k_EMsgGCFantasyLeagueFriendJoinListResponse": 7341, + "k_EMsgGCClientSuspended": 7342, + "k_EMsgGCPartyMemberSetCoach": 7343, + "k_EMsgGCFantasyLeagueEditInvitesRequest": 7344, + "k_EMsgGCFantasyLeagueEditInvitesResponse": 7345, + "k_EMsgGCPracticeLobbySetCoach": 7346, + "k_EMsgGCFantasyLeagueEditInfoRequest": 7347, + "k_EMsgGCFantasyLeagueEditInfoResponse": 7348, + "k_EMsgGCFantasyLeagueDraftStatusRequest": 7349, + "k_EMsgGCFantasyLeagueDraftStatus": 7350, + "k_EMsgGCFantasyLeagueDraftPlayerRequest": 7351, + "k_EMsgGCFantasyLeagueDraftPlayerResponse": 7352, + "k_EMsgGCFantasyLeagueMatchupsRequest": 7353, + "k_EMsgGCFantasyLeagueMatchupsResponse": 7354, + "k_EMsgGCFantasyTeamRosterSwapRequest": 7355, + "k_EMsgGCFantasyTeamRosterSwapResponse": 7356, + "k_EMsgGCFantasyTeamRosterRequest": 7357, + "k_EMsgGCFantasyTeamRosterResponse": 7358, + "k_EMsgGCNexonPartnerUpdate": 7359, + "k_EMsgGCToGCProcessPCBangRewardPoints": 7360, + "k_EMsgGCFantasyTeamRosterAddDropRequest": 7361, + "k_EMsgGCFantasyTeamRosterAddDropResponse": 7362, + "k_EMsgPresentedClientTerminateDlg": 7363, + "k_EMsgGCFantasyPlayerHisoricalStatsRequest": 7364, + "k_EMsgGCFantasyPlayerHisoricalStatsResponse": 7365, + "k_EMsgGCPCBangTimedRewardMessage": 7366, + "k_EMsgGCLobbyUpdateBroadcastChannelInfo": 7367, + "k_EMsgGCFantasyTeamTradesRequest": 7368, + "k_EMsgGCFantasyTeamTradesResponse": 7369, + "k_EMsgGCFantasyTeamTradeCancelRequest": 7370, + "k_EMsgGCFantasyTeamTradeCancelResponse": 7371, + "k_EMsgGCToGCGrantTournamentItem": 7372, + "k_EMsgGCProcessFantasyScheduledEvent": 7373, + "k_EMsgGCToGCGrantPCBangRewardItem": 7374, + "k_EMsgGCToGCUpgradeTwitchViewerItems": 7375, + "k_EMsgGCToGCGetLiveMatchAffiliates": 7376, + "k_EMsgGCToGCGetLiveMatchAffiliatesResponse": 7377, + "k_EMsgGCToGCUpdatePlayerPennantCounts": 7378, + "k_EMsgGCToGCGetPlayerPennantCounts": 7379, + "k_EMsgGCToGCGetPlayerPennantCountsResponse": 7380, + "k_EMsgGCGameMatchSignOutPermissionRequest": 7381, + "k_EMsgGCGameMatchSignOutPermissionResponse": 7382, + "k_EMsgDOTAChatChannelMemberUpdate": 7383, + "k_EMsgDOTAAwardEventPoints": 7384, + "k_EMsgDOTARedeemEventPrize": 7385, + "k_EMsgDOTARedeemEventPrizeResponse": 7386, + "k_EMsgDOTAGetEventPoints": 7387, + "k_EMsgDOTAGetEventPointsResponse": 7388, + "k_EMsgGCToGCSignoutAwardEventPoints": 7390, + "k_EMsgDOTASendFriendRecruits": 7393, + "k_EMsgDOTAFriendRecruitsRequest": 7394, + "k_EMsgDOTAFriendRecruitsResponse": 7395, + "k_EMsgDOTAFriendRecruitInviteAcceptDecline": 7396, + "k_EMsgGCPartyLeaderWatchGamePrompt": 7397, + "k_EMsgDOTAFrostivusTimeElapsed": 7398, + "k_EMsgGCToGCGrantEarnedLicense": 7399, + "k_EMsgDOTALiveLeagueGameUpdate": 7402, + "k_EMsgDOTAChatGetUserList": 7403, + "k_EMsgDOTAChatGetUserListResponse": 7404, + "k_EMsgGCCompendiumSetSelection": 7405, + "k_EMsgGCCompendiumDataRequest": 7406, + "k_EMsgGCCompendiumDataResponse": 7407, + "k_EMsgDOTAGetPlayerMatchHistory": 7408, + "k_EMsgDOTAGetPlayerMatchHistoryResponse": 7409, + "k_EMsgGCToGCMatchmakingAddParty": 7410, + "k_EMsgGCToGCMatchmakingRemoveParty": 7411, + "k_EMsgGCToGCMatchmakingRemoveAllParties": 7412, + "k_EMsgGCToGCMatchmakingMatchFound": 7413, + "k_EMsgGCToGCUpdateMatchManagementStats": 7414, + "k_EMsgGCToGCUpdateMatchmakingStats": 7415, + "k_EMsgGCToServerPingRequest": 7416, + "k_EMsgGCToServerPingResponse": 7417, + "k_EMsgGCToServerConsoleCommand": 7418, + "k_EMsgGCToGCUpdateLiveLeagueGameInfo": 7420, + "k_EMsgGCMakeOffering": 7423, + "k_EMsgGCRequestOfferings": 7424, + "k_EMsgGCRequestOfferingsResponse": 7425, + "k_EMsgGCToGCProcessMatchLeaver": 7426, + "k_EMsgGCNotificationsRequest": 7427, + "k_EMsgGCNotificationsResponse": 7428, + "k_EMsgGCToGCModifyNotification": 7429, + "k_EMsgGCToGCSetNewNotifications": 7430, + "k_EMsgGCToGCSetIsLeagueAdmin": 7431, + "k_EMsgGCLeagueAdminState": 7432, + "k_EMsgGCToGCSendLeagueAdminState": 7433, + "k_EMsgGCLeagueAdminList": 7434, + "k_EMsgGCNotificationsMarkReadRequest": 7435, + "k_EMsgGCFantasyMessageAdd": 7436, + "k_EMsgGCFantasyMessagesRequest": 7437, + "k_EMsgGCFantasyMessagesResponse": 7438, + "k_EMsgGCFantasyScheduledMatchesRequest": 7439, + "k_EMsgGCFantasyScheduledMatchesResponse": 7440, + "k_EMsgGCToGCGrantLeagueAccess": 7441, + "k_EMsgGCEventGameCreate": 7443, + "k_EMsgGCPerfectWorldUserLookupRequest": 7444, + "k_EMsgGCPerfectWorldUserLookupResponse": 7445, + "k_EMsgGCToGCIncrementRecruitmentSDO": 7446, + "k_EMsgGCToGCIncrementRecruitmentLevel": 7447, + "k_EMsgGCFantasyRemoveOwner": 7448, + "k_EMsgGCFantasyRemoveOwnerResponse": 7449, + "k_EMsgGCRequestBatchPlayerResources": 7450, + "k_EMsgGCRequestBatchPlayerResourcesResponse": 7451, + "k_EMsgGCToGCSendUpdateLeagues": 7452, + "k_EMsgGCCompendiumSetSelectionResponse": 7453, + "k_EMsgGCPlayerInfoRequest": 7454, + "k_EMsgGCPlayerInfo": 7455, + "k_EMsgGCPlayerInfoSubmit": 7456, + "k_EMsgGCPlayerInfoSubmitResponse": 7457, + "k_EMsgGCToGCGetAccountLevel": 7458, + "k_EMsgGCToGCGetAccountLevelResponse": 7459, + "k_EMsgGCToGCGetAccountPartner": 7460, + "k_EMsgGCToGCGetAccountPartnerResponse": 7461, + "k_EMsgGCToGCGetAccountProfile": 7462, + "k_EMsgGCToGCGetAccountProfileResponse": 7463, + "k_EMsgDOTAGetWeekendTourneySchedule": 7464, + "k_EMsgDOTAWeekendTourneySchedule": 7465, + "k_EMsgGCJoinableCustomGameModesRequest": 7466, + "k_EMsgGCJoinableCustomGameModesResponse": 7467, + "k_EMsgGCJoinableCustomLobbiesRequest": 7468, + "k_EMsgGCJoinableCustomLobbiesResponse": 7469, + "k_EMsgGCQuickJoinCustomLobby": 7470, + "k_EMsgGCQuickJoinCustomLobbyResponse": 7471, + "k_EMsgGCToGCGrantEventPointAction": 7472, + "k_EMsgServerGetEventPoints": 7473, + "k_EMsgServerGetEventPointsResponse": 7474, + "k_EMsgServerGrantSurveyPermission": 7475, + "k_EMsgServerGrantSurveyPermissionResponse": 7476, + "k_EMsgClientProvideSurveyResult": 7477, + "k_EMsgGCToGCSetCompendiumSelection": 7478, + "k_EMsgGCToGCUpdateTI4HeroQuest": 7480, + "k_EMsgGCCompendiumDataChanged": 7481, + "k_EMsgDOTAFantasyLeagueFindRequest": 7482, + "k_EMsgDOTAFantasyLeagueFindResponse": 7483, + "k_EMsgGCHasItemQuery": 7484, + "k_EMsgGCHasItemResponse": 7485, + "k_EMsgGCConsumeFantasyTicket": 7486, + "k_EMsgGCConsumeFantasyTicketFailure": 7487, + "k_EMsgGCToGCGrantEventPointActionMsg": 7488, + "k_EMsgClientToGCTrackDialogResult": 7489, + "k_EMsgGCFantasyLeaveLeagueRequest": 7490, + "k_EMsgGCFantasyLeaveLeagueResponse": 7491, + "k_EMsgGCToGCGetCompendiumSelections": 7492, + "k_EMsgGCToGCGetCompendiumSelectionsResponse": 7493, + "k_EMsgServerToGCMatchConnectionStats": 7494, + "k_EMsgGCToClientTournamentItemDrop": 7495, + "k_EMsgSQLDelayedGrantLeagueDrop": 7496, + "k_EMsgServerGCUpdateSpectatorCount": 7497, + "k_EMsgDOTAStartDailyHeroChallengeRequest": 7498, + "k_EMsgGCFantasyPlayerScoreDetailsRequest": 7499, + "k_EMsgGCFantasyPlayerScoreDetailsResponse": 7500, + "k_EMsgGCToGCEmoticonUnlock": 7501, + "k_EMsgSignOutDraftInfo": 7502, + "k_EMsgClientToGCEmoticonDataRequest": 7503, + "k_EMsgGCToClientEmoticonData": 7504, + "k_EMsgGCPracticeLobbyToggleBroadcastChannelCameramanStatus": 7505, + "k_EMsgGCToGCCreateWeekendTourneyRequest": 7506, + "k_EMsgGCToGCCreateWeekendTourneyResponse": 7507, + "k_EMsgGCToGCCreateGenericTeamsRequest": 7510, + "k_EMsgGCToGCCreateGenericTeamsResponse": 7511, + "k_EMsgSQLLaunchOneWeekendTourney": 7512, + "k_EMsgClientToGCSetAdditionalEquips": 7513, + "k_EMsgClientToGCGetAdditionalEquips": 7514, + "k_EMsgClientToGCGetAdditionalEquipsResponse": 7515, + "k_EMsgServerToGCGetAdditionalEquips": 7516, + "k_EMsgServerToGCGetAdditionalEquipsResponse": 7517, + "k_EMsgDOTARedeemItem": 7518, + "k_EMsgDOTARedeemItemResponse": 7519, + "k_EMsgSQLGCToGCGrantAllHeroProgress": 7520, + "k_EMsgClientToGCGetAllHeroProgress": 7521, + "k_EMsgClientToGCGetAllHeroProgressResponse": 7522, + "k_EMsgGCToGCGetServerForClient": 7523, + "k_EMsgGCToGCGetServerForClientResponse": 7524, + "k_EMsgSQLProcessTournamentGameOutcome": 7525, + "k_EMsgSQLGrantTrophyToAccount": 7526, + "k_EMsgClientToGCGetTrophyList": 7527, + "k_EMsgClientToGCGetTrophyListResponse": 7528, + "k_EMsgGCToClientTrophyAwarded": 7529, + "k_EMsgGCGameBotMatchSignOut": 7530, + "k_EMsgGCGameBotMatchSignOutPermissionRequest": 7531, + "k_EMsgSignOutBotInfo": 7532, + "k_EMsgGCToGCUpdateProfileCards": 7533, + "k_EMsgClientToGCGetProfileCard": 7534, + "k_EMsgClientToGCGetProfileCardResponse": 7535, + "k_EMsgServerToGCGetProfileCard": 7536, + "k_EMsgServerToGCGetProfileCardResponse": 7537, + "k_EMsgClientToGCSetProfileCardSlots": 7538, + "k_EMsgGCToClientProfileCardUpdated": 7539, + "k_EMsgServerToGCVictoryPredictions": 7540, + "k_EMsgClientToGCMarkNotificationListRead": 7542, + "k_EMsgGCToClientNewNotificationAdded": 7543, + "k_EMsgServerToGCSuspiciousActivity": 7544, + "k_EMsgSignOutCommunicationSummary": 7545, + "k_EMsgServerToGCRequestStatus_Response": 7546, + "k_EMsgClientToGCCreateHeroStatue": 7547, + "k_EMsgGCToClientHeroStatueCreateResult": 7548, + "k_EMsgGCGCToLANServerRelayConnect": 7549, + "k_EMsgSignOutAssassinMiniGameInfo": 7550, + "k_EMsgServerToGCGetIngameEventData": 7551, + "k_EMsgGCToGCUpdateIngameEventDataBroadcast": 7552, + "k_EMsgGCToServerIngameEventData_OraclePA": 7553, + "k_EMsgServerToGCReportKillSummaries": 7554, + "k_EMsgGCToGCReportKillSummaries": 7555, + "k_EMsgGCToGCUpdateAssassinMinigame": 7556, + "k_EMsgGCToGCFantasySetMatchLeague": 7557, + "k_EMsgClientToGCRecordCompendiumStats": 7558, + "k_EMsgGCItemEditorRequestLeagueInfo": 7559, + "k_EMsgGCItemEditorLeagueInfoResponse": 7560, + "k_EMsgGCToGCUpdatePlayerPredictions": 7561, + "k_EMsgGCToServerPredictionResult": 7562, + "k_EMsgServerToGCSignoutAwardAdditionalDrops": 7563, + "k_EMsgGCToGCSignoutAwardAdditionalDrops": 7564, + "k_EMsgGCToClientEventStatusChanged": 7565, + "k_EMsgGCHasItemDefsQuery": 7566, + "k_EMsgGCHasItemDefsResponse": 7567, + "k_EMsgGCToGCReplayMonitorValidateReplay": 7569, + "k_EMsgLobbyEventPoints": 7572, + "k_EMsgGCToGCGetCustomGameTickets": 7573, + "k_EMsgGCToGCGetCustomGameTicketsResponse": 7574, + "k_EMsgGCToClientNewBloomTimingUpdated": 7575, + "k_EMsgGCToGCCustomGamePlayed": 7576, + "k_EMsgGCToGCGrantEventPointsToUser": 7577, + "k_EMsgGCToGCSetEventMMPanicFlushTime": 7578, + "k_EMsgGameserverCrashReport": 7579, + "k_EMsgGameserverCrashReportResponse": 7580, + "k_EMsgGCToClientSteamDatagramTicket": 7581, + "k_EMsgGCToGCGrantEventOwnership": 7582, + "k_EMsgGCToGCSendAccountsEventPoints": 7583, + "k_EMsgClientToGCRerollPlayerChallenge": 7584, + "k_EMsgServerToGCRerollPlayerChallenge": 7585, + "k_EMsgGCRerollPlayerChallengeResponse": 7586, + "k_EMsgSignOutUpdatePlayerChallenge": 7587, + "k_EMsgClientToGCSetPartyLeader": 7588, + "k_EMsgClientToGCCancelPartyInvites": 7589, + "k_EMsgGCToGCMasterReloadAccount": 7590, + "k_EMsgSQLGrantLeagueMatchToTicketHolders": 7592, + "k_EMsgClientToGCSetAdditionalEquipsResponse": 7593, + "k_EMsgGCToGCEmoticonUnlockNoRollback": 7594, + "k_EMsgGCToGCGetCompendiumFanfare": 7595, + "k_EMsgServerToGCHoldEventPoints": 7596, + "k_EMsgSignOutReleaseEventPointHolds": 7597, + "k_EMsgGCToGCChatNewUserSession": 7598, + "k_EMsgClientToGCGetLeagueSeries": 7599, + "k_EMsgClientToGCGetLeagueSeriesResponse": 7600, + "k_EMsgSQLGCToGCSignoutUpdateLeagueSchedule": 7601, + "k_EMsgGCToServerUpdateBroadcastCheers": 7602, + "k_EMsgClientToGCApplyGemCombiner": 7603, + "k_EMsgClientToGCCreateStaticRecipe": 7604, + "k_EMsgClientToGCCreateStaticRecipeResponse": 7605, + "k_EMsgClientToGCGetAllHeroOrder": 7606, + "k_EMsgClientToGCGetAllHeroOrderResponse": 7607, + "k_EMsgSQLGCToGCGrantBadgePoints": 7608, + "k_EMsgGCToGCGetAccountMatchStatus": 7609, + "k_EMsgGCToGCGetAccountMatchStatusResponse": 7610, + "k_EMsgGCDev_GrantWarKill": 8001, + "k_EMsgClientToGCCreateTeamShowcase": 8002, + "k_EMsgGCToClientTeamShowcaseCreateResult": 8003, + "k_EMsgServerToGCLockCharmTrading": 8004, + "k_EMsgDOTACNY2015EventPointUsage": 8005, + "k_EMsgClientToGCPlayerStatsRequest": 8006, + "k_EMsgGCToClientPlayerStatsResponse": 8007, + "k_EMsgGCClearPracticeLobbyTeam": 8008, + "k_EMsgClientToGCFindTopSourceTVGames": 8009, + "k_EMsgGCToClientFindTopSourceTVGamesResponse": 8010, + "k_EMsgGCLobbyList": 8011, + "k_EMsgGCLobbyListResponse": 8012, + "k_EMsgGCPlayerStatsMatchSignOut": 8013, + "k_EMsgClientToGCCustomGamePlayerCountRequest": 8014, + "k_EMsgGCToClientCustomGamePlayerCountResponse": 8015, + "k_EMsgClientToGCSocialFeedPostCommentRequest": 8016, + "k_EMsgGCToClientSocialFeedPostCommentResponse": 8017, + "k_EMsgClientToGCCustomGamesFriendsPlayedRequest": 8018, + "k_EMsgGCToClientCustomGamesFriendsPlayedResponse": 8019, + "k_EMsgClientToGCFriendsPlayedCustomGameRequest": 8020, + "k_EMsgGCToClientFriendsPlayedCustomGameResponse": 8021, + "k_EMsgClientToGCFeaturedHeroesRequest": 8022, + "k_EMsgGCToClientFeaturedHeroesResponse": 8023, + "k_EMsgGCTopCustomGamesList": 8024, + "k_EMsgClientToGCSocialMatchPostCommentRequest": 8025, + "k_EMsgGCToClientSocialMatchPostCommentResponse": 8026, + "k_EMsgClientToGCSocialMatchDetailsRequest": 8027, + "k_EMsgGCToClientSocialMatchDetailsResponse": 8028, + "k_EMsgClientToGCSetPartyOpen": 8029, + "k_EMsgClientToGCMergePartyInvite": 8030, + "k_EMsgGCToClientMergeGroupInviteReply": 8031, + "k_EMsgClientToGCMergePartyResponse": 8032, + "k_EMsgGCToClientMergePartyResponseReply": 8033, + "k_EMsgClientToGCGetProfileCardStats": 8034, + "k_EMsgClientToGCGetProfileCardStatsResponse": 8035, + "k_EMsgClientToGCTopLeagueMatchesRequest": 8036, + "k_EMsgClientToGCTopFriendMatchesRequest": 8037, + "k_EMsgGCToClientProfileCardStatsUpdated": 8040, + "k_EMsgServerToGCRealtimeStats": 8041, + "k_EMsgGCToServerRealtimeStatsStartStop": 8042, + "k_EMsgGCToGCGetServersForClients": 8045, + "k_EMsgGCToGCGetServersForClientsResponse": 8046, + "k_EMsgGCPracticeLobbyKickFromTeam": 8047, + "k_EMsgDOTAChatGetMemberCount": 8048, + "k_EMsgDOTAChatGetMemberCountResponse": 8049, + "k_EMsgClientToGCSocialFeedPostMessageRequest": 8050, + "k_EMsgGCToClientSocialFeedPostMessageResponse": 8051, + "k_EMsgCustomGameListenServerStartedLoading": 8052, + "k_EMsgCustomGameClientFinishedLoading": 8053, + "k_EMsgGCPracticeLobbyCloseBroadcastChannel": 8054, + "k_EMsgGCStartFindingMatchResponse": 8055, + "k_EMsgSQLGCToGCUpdateHeroMMR": 8056, + "k_EMsgSQLGCToGCGrantAccountFlag": 8057, + "k_EMsgGCToGCGetAccountFlags": 8058, + "k_EMsgGCToGCGetAccountFlagsResponse": 8059, + "k_EMsgSignOutWagerStats": 8060, + "k_EMsgGCToClientTopLeagueMatchesResponse": 8061, + "k_EMsgGCToClientTopFriendMatchesResponse": 8062, + "k_EMsgClientToGCMatchesMinimalRequest": 8063, + "k_EMsgClientToGCMatchesMinimalResponse": 8064, + "k_EMsgGCToGCGetProfileBadgePoints": 8065, + "k_EMsgGCToGCGetProfileBadgePointsResponse": 8066, + "k_EMsgGCToClientChatRegionsEnabled": 8067, + "k_EMsgClientToGCPingData": 8068, + "k_EMsgServerToGCMatchDetailsRequest": 8069, + "k_EMsgGCToServerMatchDetailsResponse": 8070, + "k_EMsgGCToGCEnsureAccountInParty": 8071, + "k_EMsgGCToGCEnsureAccountInPartyResponse": 8072, + "k_EMsgClientToGCGetProfileTickets": 8073, + "k_EMsgClientToGCGetProfileTicketsResponse": 8074, + "k_EMsgGCToClientMatchGroupsVersion": 8075, + "k_EMsgClientToGCH264Unsupported": 8076, + "k_EMsgClientToGCRequestH264Support": 8077, + "k_EMsgClientToGCGetQuestProgress": 8078, + "k_EMsgClientToGCGetQuestProgressResponse": 8079, + "k_EMsgSignOutXPCoins": 8080, + "k_EMsgGCToClientMatchSignedOut": 8081, + "k_EMsgGCGetHeroStatsHistory": 8082, + "k_EMsgGCGetHeroStatsHistoryResponse": 8083, + "k_EMsgClientToGCPrivateChatInvite": 8084, + "k_EMsgClientToGCPrivateChatKick": 8088, + "k_EMsgClientToGCPrivateChatPromote": 8089, + "k_EMsgClientToGCPrivateChatDemote": 8090, + "k_EMsgGCToClientPrivateChatResponse": 8091, + "k_EMsgClientToGCPrivateChatInfoRequest": 8092, + "k_EMsgGCToClientPrivateChatInfoResponse": 8093, + "k_EMsgClientToGCLatestBehaviorReportRequest": 8095, + "k_EMsgClientToGCLatestBehaviorReport": 8096, +} + +func (x EDOTAGCMsg) Enum() *EDOTAGCMsg { + p := new(EDOTAGCMsg) + *p = x + return p +} +func (x EDOTAGCMsg) String() string { + return proto.EnumName(EDOTAGCMsg_name, int32(x)) +} +func (x *EDOTAGCMsg) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EDOTAGCMsg_value, data, "EDOTAGCMsg") + if err != nil { + return err + } + *x = EDOTAGCMsg(value) + return nil +} +func (EDOTAGCMsg) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{0} } + +type ESpecialPingValue int32 + +const ( + ESpecialPingValue_k_ESpecialPingValue_NoData ESpecialPingValue = 16382 + ESpecialPingValue_k_ESpecialPingValue_Failed ESpecialPingValue = 16383 +) + +var ESpecialPingValue_name = map[int32]string{ + 16382: "k_ESpecialPingValue_NoData", + 16383: "k_ESpecialPingValue_Failed", +} +var ESpecialPingValue_value = map[string]int32{ + "k_ESpecialPingValue_NoData": 16382, + "k_ESpecialPingValue_Failed": 16383, +} + +func (x ESpecialPingValue) Enum() *ESpecialPingValue { + p := new(ESpecialPingValue) + *p = x + return p +} +func (x ESpecialPingValue) String() string { + return proto.EnumName(ESpecialPingValue_name, int32(x)) +} +func (x *ESpecialPingValue) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ESpecialPingValue_value, data, "ESpecialPingValue") + if err != nil { + return err + } + *x = ESpecialPingValue(value) + return nil +} +func (ESpecialPingValue) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{1} } + +type DOTA_GameMode int32 + +const ( + DOTA_GameMode_DOTA_GAMEMODE_NONE DOTA_GameMode = 0 + DOTA_GameMode_DOTA_GAMEMODE_AP DOTA_GameMode = 1 + DOTA_GameMode_DOTA_GAMEMODE_CM DOTA_GameMode = 2 + DOTA_GameMode_DOTA_GAMEMODE_RD DOTA_GameMode = 3 + DOTA_GameMode_DOTA_GAMEMODE_SD DOTA_GameMode = 4 + DOTA_GameMode_DOTA_GAMEMODE_AR DOTA_GameMode = 5 + DOTA_GameMode_DOTA_GAMEMODE_INTRO DOTA_GameMode = 6 + DOTA_GameMode_DOTA_GAMEMODE_HW DOTA_GameMode = 7 + DOTA_GameMode_DOTA_GAMEMODE_REVERSE_CM DOTA_GameMode = 8 + DOTA_GameMode_DOTA_GAMEMODE_XMAS DOTA_GameMode = 9 + DOTA_GameMode_DOTA_GAMEMODE_TUTORIAL DOTA_GameMode = 10 + DOTA_GameMode_DOTA_GAMEMODE_MO DOTA_GameMode = 11 + DOTA_GameMode_DOTA_GAMEMODE_LP DOTA_GameMode = 12 + DOTA_GameMode_DOTA_GAMEMODE_POOL1 DOTA_GameMode = 13 + DOTA_GameMode_DOTA_GAMEMODE_FH DOTA_GameMode = 14 + DOTA_GameMode_DOTA_GAMEMODE_CUSTOM DOTA_GameMode = 15 + DOTA_GameMode_DOTA_GAMEMODE_CD DOTA_GameMode = 16 + DOTA_GameMode_DOTA_GAMEMODE_BD DOTA_GameMode = 17 + DOTA_GameMode_DOTA_GAMEMODE_ABILITY_DRAFT DOTA_GameMode = 18 + DOTA_GameMode_DOTA_GAMEMODE_EVENT DOTA_GameMode = 19 + DOTA_GameMode_DOTA_GAMEMODE_ARDM DOTA_GameMode = 20 + DOTA_GameMode_DOTA_GAMEMODE_1V1MID DOTA_GameMode = 21 + DOTA_GameMode_DOTA_GAMEMODE_ALL_DRAFT DOTA_GameMode = 22 +) + +var DOTA_GameMode_name = map[int32]string{ + 0: "DOTA_GAMEMODE_NONE", + 1: "DOTA_GAMEMODE_AP", + 2: "DOTA_GAMEMODE_CM", + 3: "DOTA_GAMEMODE_RD", + 4: "DOTA_GAMEMODE_SD", + 5: "DOTA_GAMEMODE_AR", + 6: "DOTA_GAMEMODE_INTRO", + 7: "DOTA_GAMEMODE_HW", + 8: "DOTA_GAMEMODE_REVERSE_CM", + 9: "DOTA_GAMEMODE_XMAS", + 10: "DOTA_GAMEMODE_TUTORIAL", + 11: "DOTA_GAMEMODE_MO", + 12: "DOTA_GAMEMODE_LP", + 13: "DOTA_GAMEMODE_POOL1", + 14: "DOTA_GAMEMODE_FH", + 15: "DOTA_GAMEMODE_CUSTOM", + 16: "DOTA_GAMEMODE_CD", + 17: "DOTA_GAMEMODE_BD", + 18: "DOTA_GAMEMODE_ABILITY_DRAFT", + 19: "DOTA_GAMEMODE_EVENT", + 20: "DOTA_GAMEMODE_ARDM", + 21: "DOTA_GAMEMODE_1V1MID", + 22: "DOTA_GAMEMODE_ALL_DRAFT", +} +var DOTA_GameMode_value = map[string]int32{ + "DOTA_GAMEMODE_NONE": 0, + "DOTA_GAMEMODE_AP": 1, + "DOTA_GAMEMODE_CM": 2, + "DOTA_GAMEMODE_RD": 3, + "DOTA_GAMEMODE_SD": 4, + "DOTA_GAMEMODE_AR": 5, + "DOTA_GAMEMODE_INTRO": 6, + "DOTA_GAMEMODE_HW": 7, + "DOTA_GAMEMODE_REVERSE_CM": 8, + "DOTA_GAMEMODE_XMAS": 9, + "DOTA_GAMEMODE_TUTORIAL": 10, + "DOTA_GAMEMODE_MO": 11, + "DOTA_GAMEMODE_LP": 12, + "DOTA_GAMEMODE_POOL1": 13, + "DOTA_GAMEMODE_FH": 14, + "DOTA_GAMEMODE_CUSTOM": 15, + "DOTA_GAMEMODE_CD": 16, + "DOTA_GAMEMODE_BD": 17, + "DOTA_GAMEMODE_ABILITY_DRAFT": 18, + "DOTA_GAMEMODE_EVENT": 19, + "DOTA_GAMEMODE_ARDM": 20, + "DOTA_GAMEMODE_1V1MID": 21, + "DOTA_GAMEMODE_ALL_DRAFT": 22, +} + +func (x DOTA_GameMode) Enum() *DOTA_GameMode { + p := new(DOTA_GameMode) + *p = x + return p +} +func (x DOTA_GameMode) String() string { + return proto.EnumName(DOTA_GameMode_name, int32(x)) +} +func (x *DOTA_GameMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_GameMode_value, data, "DOTA_GameMode") + if err != nil { + return err + } + *x = DOTA_GameMode(value) + return nil +} +func (DOTA_GameMode) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{2} } + +type DOTA_GameState int32 + +const ( + DOTA_GameState_DOTA_GAMERULES_STATE_INIT DOTA_GameState = 0 + DOTA_GameState_DOTA_GAMERULES_STATE_WAIT_FOR_PLAYERS_TO_LOAD DOTA_GameState = 1 + DOTA_GameState_DOTA_GAMERULES_STATE_HERO_SELECTION DOTA_GameState = 2 + DOTA_GameState_DOTA_GAMERULES_STATE_STRATEGY_TIME DOTA_GameState = 3 + DOTA_GameState_DOTA_GAMERULES_STATE_PRE_GAME DOTA_GameState = 4 + DOTA_GameState_DOTA_GAMERULES_STATE_GAME_IN_PROGRESS DOTA_GameState = 5 + DOTA_GameState_DOTA_GAMERULES_STATE_POST_GAME DOTA_GameState = 6 + DOTA_GameState_DOTA_GAMERULES_STATE_DISCONNECT DOTA_GameState = 7 + DOTA_GameState_DOTA_GAMERULES_STATE_TEAM_SHOWCASE DOTA_GameState = 8 + DOTA_GameState_DOTA_GAMERULES_STATE_CUSTOM_GAME_SETUP DOTA_GameState = 9 + DOTA_GameState_DOTA_GAMERULES_STATE_LAST DOTA_GameState = 10 +) + +var DOTA_GameState_name = map[int32]string{ + 0: "DOTA_GAMERULES_STATE_INIT", + 1: "DOTA_GAMERULES_STATE_WAIT_FOR_PLAYERS_TO_LOAD", + 2: "DOTA_GAMERULES_STATE_HERO_SELECTION", + 3: "DOTA_GAMERULES_STATE_STRATEGY_TIME", + 4: "DOTA_GAMERULES_STATE_PRE_GAME", + 5: "DOTA_GAMERULES_STATE_GAME_IN_PROGRESS", + 6: "DOTA_GAMERULES_STATE_POST_GAME", + 7: "DOTA_GAMERULES_STATE_DISCONNECT", + 8: "DOTA_GAMERULES_STATE_TEAM_SHOWCASE", + 9: "DOTA_GAMERULES_STATE_CUSTOM_GAME_SETUP", + 10: "DOTA_GAMERULES_STATE_LAST", +} +var DOTA_GameState_value = map[string]int32{ + "DOTA_GAMERULES_STATE_INIT": 0, + "DOTA_GAMERULES_STATE_WAIT_FOR_PLAYERS_TO_LOAD": 1, + "DOTA_GAMERULES_STATE_HERO_SELECTION": 2, + "DOTA_GAMERULES_STATE_STRATEGY_TIME": 3, + "DOTA_GAMERULES_STATE_PRE_GAME": 4, + "DOTA_GAMERULES_STATE_GAME_IN_PROGRESS": 5, + "DOTA_GAMERULES_STATE_POST_GAME": 6, + "DOTA_GAMERULES_STATE_DISCONNECT": 7, + "DOTA_GAMERULES_STATE_TEAM_SHOWCASE": 8, + "DOTA_GAMERULES_STATE_CUSTOM_GAME_SETUP": 9, + "DOTA_GAMERULES_STATE_LAST": 10, +} + +func (x DOTA_GameState) Enum() *DOTA_GameState { + p := new(DOTA_GameState) + *p = x + return p +} +func (x DOTA_GameState) String() string { + return proto.EnumName(DOTA_GameState_name, int32(x)) +} +func (x *DOTA_GameState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_GameState_value, data, "DOTA_GameState") + if err != nil { + return err + } + *x = DOTA_GameState(value) + return nil +} +func (DOTA_GameState) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{3} } + +type DOTA_GC_TEAM int32 + +const ( + DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS DOTA_GC_TEAM = 0 + DOTA_GC_TEAM_DOTA_GC_TEAM_BAD_GUYS DOTA_GC_TEAM = 1 + DOTA_GC_TEAM_DOTA_GC_TEAM_BROADCASTER DOTA_GC_TEAM = 2 + DOTA_GC_TEAM_DOTA_GC_TEAM_SPECTATOR DOTA_GC_TEAM = 3 + DOTA_GC_TEAM_DOTA_GC_TEAM_PLAYER_POOL DOTA_GC_TEAM = 4 + DOTA_GC_TEAM_DOTA_GC_TEAM_NOTEAM DOTA_GC_TEAM = 5 +) + +var DOTA_GC_TEAM_name = map[int32]string{ + 0: "DOTA_GC_TEAM_GOOD_GUYS", + 1: "DOTA_GC_TEAM_BAD_GUYS", + 2: "DOTA_GC_TEAM_BROADCASTER", + 3: "DOTA_GC_TEAM_SPECTATOR", + 4: "DOTA_GC_TEAM_PLAYER_POOL", + 5: "DOTA_GC_TEAM_NOTEAM", +} +var DOTA_GC_TEAM_value = map[string]int32{ + "DOTA_GC_TEAM_GOOD_GUYS": 0, + "DOTA_GC_TEAM_BAD_GUYS": 1, + "DOTA_GC_TEAM_BROADCASTER": 2, + "DOTA_GC_TEAM_SPECTATOR": 3, + "DOTA_GC_TEAM_PLAYER_POOL": 4, + "DOTA_GC_TEAM_NOTEAM": 5, +} + +func (x DOTA_GC_TEAM) Enum() *DOTA_GC_TEAM { + p := new(DOTA_GC_TEAM) + *p = x + return p +} +func (x DOTA_GC_TEAM) String() string { + return proto.EnumName(DOTA_GC_TEAM_name, int32(x)) +} +func (x *DOTA_GC_TEAM) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_GC_TEAM_value, data, "DOTA_GC_TEAM") + if err != nil { + return err + } + *x = DOTA_GC_TEAM(value) + return nil +} +func (DOTA_GC_TEAM) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{4} } + +type DOTA_CM_PICK int32 + +const ( + DOTA_CM_PICK_DOTA_CM_RANDOM DOTA_CM_PICK = 0 + DOTA_CM_PICK_DOTA_CM_GOOD_GUYS DOTA_CM_PICK = 1 + DOTA_CM_PICK_DOTA_CM_BAD_GUYS DOTA_CM_PICK = 2 +) + +var DOTA_CM_PICK_name = map[int32]string{ + 0: "DOTA_CM_RANDOM", + 1: "DOTA_CM_GOOD_GUYS", + 2: "DOTA_CM_BAD_GUYS", +} +var DOTA_CM_PICK_value = map[string]int32{ + "DOTA_CM_RANDOM": 0, + "DOTA_CM_GOOD_GUYS": 1, + "DOTA_CM_BAD_GUYS": 2, +} + +func (x DOTA_CM_PICK) Enum() *DOTA_CM_PICK { + p := new(DOTA_CM_PICK) + *p = x + return p +} +func (x DOTA_CM_PICK) String() string { + return proto.EnumName(DOTA_CM_PICK_name, int32(x)) +} +func (x *DOTA_CM_PICK) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_CM_PICK_value, data, "DOTA_CM_PICK") + if err != nil { + return err + } + *x = DOTA_CM_PICK(value) + return nil +} +func (DOTA_CM_PICK) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{5} } + +type DOTAConnectionStateT int32 + +const ( + DOTAConnectionStateT_DOTA_CONNECTION_STATE_UNKNOWN DOTAConnectionStateT = 0 + DOTAConnectionStateT_DOTA_CONNECTION_STATE_NOT_YET_CONNECTED DOTAConnectionStateT = 1 + DOTAConnectionStateT_DOTA_CONNECTION_STATE_CONNECTED DOTAConnectionStateT = 2 + DOTAConnectionStateT_DOTA_CONNECTION_STATE_DISCONNECTED DOTAConnectionStateT = 3 + DOTAConnectionStateT_DOTA_CONNECTION_STATE_ABANDONED DOTAConnectionStateT = 4 + DOTAConnectionStateT_DOTA_CONNECTION_STATE_LOADING DOTAConnectionStateT = 5 + DOTAConnectionStateT_DOTA_CONNECTION_STATE_FAILED DOTAConnectionStateT = 6 +) + +var DOTAConnectionStateT_name = map[int32]string{ + 0: "DOTA_CONNECTION_STATE_UNKNOWN", + 1: "DOTA_CONNECTION_STATE_NOT_YET_CONNECTED", + 2: "DOTA_CONNECTION_STATE_CONNECTED", + 3: "DOTA_CONNECTION_STATE_DISCONNECTED", + 4: "DOTA_CONNECTION_STATE_ABANDONED", + 5: "DOTA_CONNECTION_STATE_LOADING", + 6: "DOTA_CONNECTION_STATE_FAILED", +} +var DOTAConnectionStateT_value = map[string]int32{ + "DOTA_CONNECTION_STATE_UNKNOWN": 0, + "DOTA_CONNECTION_STATE_NOT_YET_CONNECTED": 1, + "DOTA_CONNECTION_STATE_CONNECTED": 2, + "DOTA_CONNECTION_STATE_DISCONNECTED": 3, + "DOTA_CONNECTION_STATE_ABANDONED": 4, + "DOTA_CONNECTION_STATE_LOADING": 5, + "DOTA_CONNECTION_STATE_FAILED": 6, +} + +func (x DOTAConnectionStateT) Enum() *DOTAConnectionStateT { + p := new(DOTAConnectionStateT) + *p = x + return p +} +func (x DOTAConnectionStateT) String() string { + return proto.EnumName(DOTAConnectionStateT_name, int32(x)) +} +func (x *DOTAConnectionStateT) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTAConnectionStateT_value, data, "DOTAConnectionStateT") + if err != nil { + return err + } + *x = DOTAConnectionStateT(value) + return nil +} +func (DOTAConnectionStateT) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{6} } + +type DOTALeaverStatusT int32 + +const ( + DOTALeaverStatusT_DOTA_LEAVER_NONE DOTALeaverStatusT = 0 + DOTALeaverStatusT_DOTA_LEAVER_DISCONNECTED DOTALeaverStatusT = 1 + DOTALeaverStatusT_DOTA_LEAVER_DISCONNECTED_TOO_LONG DOTALeaverStatusT = 2 + DOTALeaverStatusT_DOTA_LEAVER_ABANDONED DOTALeaverStatusT = 3 + DOTALeaverStatusT_DOTA_LEAVER_AFK DOTALeaverStatusT = 4 + DOTALeaverStatusT_DOTA_LEAVER_NEVER_CONNECTED DOTALeaverStatusT = 5 + DOTALeaverStatusT_DOTA_LEAVER_NEVER_CONNECTED_TOO_LONG DOTALeaverStatusT = 6 + DOTALeaverStatusT_DOTA_LEAVER_FAILED_TO_READY_UP DOTALeaverStatusT = 7 + DOTALeaverStatusT_DOTA_LEAVER_DECLINED DOTALeaverStatusT = 8 +) + +var DOTALeaverStatusT_name = map[int32]string{ + 0: "DOTA_LEAVER_NONE", + 1: "DOTA_LEAVER_DISCONNECTED", + 2: "DOTA_LEAVER_DISCONNECTED_TOO_LONG", + 3: "DOTA_LEAVER_ABANDONED", + 4: "DOTA_LEAVER_AFK", + 5: "DOTA_LEAVER_NEVER_CONNECTED", + 6: "DOTA_LEAVER_NEVER_CONNECTED_TOO_LONG", + 7: "DOTA_LEAVER_FAILED_TO_READY_UP", + 8: "DOTA_LEAVER_DECLINED", +} +var DOTALeaverStatusT_value = map[string]int32{ + "DOTA_LEAVER_NONE": 0, + "DOTA_LEAVER_DISCONNECTED": 1, + "DOTA_LEAVER_DISCONNECTED_TOO_LONG": 2, + "DOTA_LEAVER_ABANDONED": 3, + "DOTA_LEAVER_AFK": 4, + "DOTA_LEAVER_NEVER_CONNECTED": 5, + "DOTA_LEAVER_NEVER_CONNECTED_TOO_LONG": 6, + "DOTA_LEAVER_FAILED_TO_READY_UP": 7, + "DOTA_LEAVER_DECLINED": 8, +} + +func (x DOTALeaverStatusT) Enum() *DOTALeaverStatusT { + p := new(DOTALeaverStatusT) + *p = x + return p +} +func (x DOTALeaverStatusT) String() string { + return proto.EnumName(DOTALeaverStatusT_name, int32(x)) +} +func (x *DOTALeaverStatusT) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTALeaverStatusT_value, data, "DOTALeaverStatusT") + if err != nil { + return err + } + *x = DOTALeaverStatusT(value) + return nil +} +func (DOTALeaverStatusT) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{7} } + +type DOTALowPriorityBanType int32 + +const ( + DOTALowPriorityBanType_DOTA_LOW_PRIORITY_BAN_ABANDON DOTALowPriorityBanType = 0 + DOTALowPriorityBanType_DOTA_LOW_PRIORITY_BAN_REPORTS DOTALowPriorityBanType = 1 + DOTALowPriorityBanType_DOTA_LOW_PRIORITY_BAN_SECONDARY_ABANDON DOTALowPriorityBanType = 2 +) + +var DOTALowPriorityBanType_name = map[int32]string{ + 0: "DOTA_LOW_PRIORITY_BAN_ABANDON", + 1: "DOTA_LOW_PRIORITY_BAN_REPORTS", + 2: "DOTA_LOW_PRIORITY_BAN_SECONDARY_ABANDON", +} +var DOTALowPriorityBanType_value = map[string]int32{ + "DOTA_LOW_PRIORITY_BAN_ABANDON": 0, + "DOTA_LOW_PRIORITY_BAN_REPORTS": 1, + "DOTA_LOW_PRIORITY_BAN_SECONDARY_ABANDON": 2, +} + +func (x DOTALowPriorityBanType) Enum() *DOTALowPriorityBanType { + p := new(DOTALowPriorityBanType) + *p = x + return p +} +func (x DOTALowPriorityBanType) String() string { + return proto.EnumName(DOTALowPriorityBanType_name, int32(x)) +} +func (x *DOTALowPriorityBanType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTALowPriorityBanType_value, data, "DOTALowPriorityBanType") + if err != nil { + return err + } + *x = DOTALowPriorityBanType(value) + return nil +} +func (DOTALowPriorityBanType) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{8} } + +type DOTALobbyReadyState int32 + +const ( + DOTALobbyReadyState_DOTALobbyReadyState_UNDECLARED DOTALobbyReadyState = 0 + DOTALobbyReadyState_DOTALobbyReadyState_ACCEPTED DOTALobbyReadyState = 1 + DOTALobbyReadyState_DOTALobbyReadyState_DECLINED DOTALobbyReadyState = 2 +) + +var DOTALobbyReadyState_name = map[int32]string{ + 0: "DOTALobbyReadyState_UNDECLARED", + 1: "DOTALobbyReadyState_ACCEPTED", + 2: "DOTALobbyReadyState_DECLINED", +} +var DOTALobbyReadyState_value = map[string]int32{ + "DOTALobbyReadyState_UNDECLARED": 0, + "DOTALobbyReadyState_ACCEPTED": 1, + "DOTALobbyReadyState_DECLINED": 2, +} + +func (x DOTALobbyReadyState) Enum() *DOTALobbyReadyState { + p := new(DOTALobbyReadyState) + *p = x + return p +} +func (x DOTALobbyReadyState) String() string { + return proto.EnumName(DOTALobbyReadyState_name, int32(x)) +} +func (x *DOTALobbyReadyState) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTALobbyReadyState_value, data, "DOTALobbyReadyState") + if err != nil { + return err + } + *x = DOTALobbyReadyState(value) + return nil +} +func (DOTALobbyReadyState) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{9} } + +type DOTAGameVersion int32 + +const ( + DOTAGameVersion_GAME_VERSION_CURRENT DOTAGameVersion = 0 + DOTAGameVersion_GAME_VERSION_STABLE DOTAGameVersion = 1 +) + +var DOTAGameVersion_name = map[int32]string{ + 0: "GAME_VERSION_CURRENT", + 1: "GAME_VERSION_STABLE", +} +var DOTAGameVersion_value = map[string]int32{ + "GAME_VERSION_CURRENT": 0, + "GAME_VERSION_STABLE": 1, +} + +func (x DOTAGameVersion) Enum() *DOTAGameVersion { + p := new(DOTAGameVersion) + *p = x + return p +} +func (x DOTAGameVersion) String() string { + return proto.EnumName(DOTAGameVersion_name, int32(x)) +} +func (x *DOTAGameVersion) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTAGameVersion_value, data, "DOTAGameVersion") + if err != nil { + return err + } + *x = DOTAGameVersion(value) + return nil +} +func (DOTAGameVersion) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{10} } + +type DOTAJoinLobbyResult int32 + +const ( + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_SUCCESS DOTAJoinLobbyResult = 0 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_ALREADY_IN_GAME DOTAJoinLobbyResult = 1 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_INVALID_LOBBY DOTAJoinLobbyResult = 2 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_INCORRECT_PASSWORD DOTAJoinLobbyResult = 3 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_ACCESS_DENIED DOTAJoinLobbyResult = 4 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_GENERIC_ERROR DOTAJoinLobbyResult = 5 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_INCORRECT_VERSION DOTAJoinLobbyResult = 6 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_IN_TEAM_PARTY DOTAJoinLobbyResult = 7 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_NO_LOBBY_FOUND DOTAJoinLobbyResult = 8 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_LOBBY_FULL DOTAJoinLobbyResult = 9 + DOTAJoinLobbyResult_DOTA_JOIN_RESULT_CUSTOM_GAME_INCORRECT_VERSION DOTAJoinLobbyResult = 10 +) + +var DOTAJoinLobbyResult_name = map[int32]string{ + 0: "DOTA_JOIN_RESULT_SUCCESS", + 1: "DOTA_JOIN_RESULT_ALREADY_IN_GAME", + 2: "DOTA_JOIN_RESULT_INVALID_LOBBY", + 3: "DOTA_JOIN_RESULT_INCORRECT_PASSWORD", + 4: "DOTA_JOIN_RESULT_ACCESS_DENIED", + 5: "DOTA_JOIN_RESULT_GENERIC_ERROR", + 6: "DOTA_JOIN_RESULT_INCORRECT_VERSION", + 7: "DOTA_JOIN_RESULT_IN_TEAM_PARTY", + 8: "DOTA_JOIN_RESULT_NO_LOBBY_FOUND", + 9: "DOTA_JOIN_RESULT_LOBBY_FULL", + 10: "DOTA_JOIN_RESULT_CUSTOM_GAME_INCORRECT_VERSION", +} +var DOTAJoinLobbyResult_value = map[string]int32{ + "DOTA_JOIN_RESULT_SUCCESS": 0, + "DOTA_JOIN_RESULT_ALREADY_IN_GAME": 1, + "DOTA_JOIN_RESULT_INVALID_LOBBY": 2, + "DOTA_JOIN_RESULT_INCORRECT_PASSWORD": 3, + "DOTA_JOIN_RESULT_ACCESS_DENIED": 4, + "DOTA_JOIN_RESULT_GENERIC_ERROR": 5, + "DOTA_JOIN_RESULT_INCORRECT_VERSION": 6, + "DOTA_JOIN_RESULT_IN_TEAM_PARTY": 7, + "DOTA_JOIN_RESULT_NO_LOBBY_FOUND": 8, + "DOTA_JOIN_RESULT_LOBBY_FULL": 9, + "DOTA_JOIN_RESULT_CUSTOM_GAME_INCORRECT_VERSION": 10, +} + +func (x DOTAJoinLobbyResult) Enum() *DOTAJoinLobbyResult { + p := new(DOTAJoinLobbyResult) + *p = x + return p +} +func (x DOTAJoinLobbyResult) String() string { + return proto.EnumName(DOTAJoinLobbyResult_name, int32(x)) +} +func (x *DOTAJoinLobbyResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTAJoinLobbyResult_value, data, "DOTAJoinLobbyResult") + if err != nil { + return err + } + *x = DOTAJoinLobbyResult(value) + return nil +} +func (DOTAJoinLobbyResult) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{11} } + +type SelectionPriorityType int32 + +const ( + SelectionPriorityType_UNDEFINED SelectionPriorityType = 0 + SelectionPriorityType_RADIANT SelectionPriorityType = 1 + SelectionPriorityType_DIRE SelectionPriorityType = 2 + SelectionPriorityType_FIRST_PICK SelectionPriorityType = 3 + SelectionPriorityType_SECOND_PICK SelectionPriorityType = 4 +) + +var SelectionPriorityType_name = map[int32]string{ + 0: "UNDEFINED", + 1: "RADIANT", + 2: "DIRE", + 3: "FIRST_PICK", + 4: "SECOND_PICK", +} +var SelectionPriorityType_value = map[string]int32{ + "UNDEFINED": 0, + "RADIANT": 1, + "DIRE": 2, + "FIRST_PICK": 3, + "SECOND_PICK": 4, +} + +func (x SelectionPriorityType) Enum() *SelectionPriorityType { + p := new(SelectionPriorityType) + *p = x + return p +} +func (x SelectionPriorityType) String() string { + return proto.EnumName(SelectionPriorityType_name, int32(x)) +} +func (x *SelectionPriorityType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(SelectionPriorityType_value, data, "SelectionPriorityType") + if err != nil { + return err + } + *x = SelectionPriorityType(value) + return nil +} +func (SelectionPriorityType) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{12} } + +type DOTAMatchVote int32 + +const ( + DOTAMatchVote_DOTAMatchVote_INVALID DOTAMatchVote = 0 + DOTAMatchVote_DOTAMatchVote_POSITIVE DOTAMatchVote = 1 + DOTAMatchVote_DOTAMatchVote_NEGATIVE DOTAMatchVote = 2 +) + +var DOTAMatchVote_name = map[int32]string{ + 0: "DOTAMatchVote_INVALID", + 1: "DOTAMatchVote_POSITIVE", + 2: "DOTAMatchVote_NEGATIVE", +} +var DOTAMatchVote_value = map[string]int32{ + "DOTAMatchVote_INVALID": 0, + "DOTAMatchVote_POSITIVE": 1, + "DOTAMatchVote_NEGATIVE": 2, +} + +func (x DOTAMatchVote) Enum() *DOTAMatchVote { + p := new(DOTAMatchVote) + *p = x + return p +} +func (x DOTAMatchVote) String() string { + return proto.EnumName(DOTAMatchVote_name, int32(x)) +} +func (x *DOTAMatchVote) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTAMatchVote_value, data, "DOTAMatchVote") + if err != nil { + return err + } + *x = DOTAMatchVote(value) + return nil +} +func (DOTAMatchVote) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{13} } + +type DOTA_LobbyMemberXPBonus int32 + +const ( + DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_DEFAULT DOTA_LobbyMemberXPBonus = 0 + DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_BATTLE_BOOSTER DOTA_LobbyMemberXPBonus = 1 + DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_SHARE_BONUS DOTA_LobbyMemberXPBonus = 2 + DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_PARTY DOTA_LobbyMemberXPBonus = 3 + DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_RECRUITMENT DOTA_LobbyMemberXPBonus = 4 + DOTA_LobbyMemberXPBonus_DOTA_LobbyMemberXPBonus_PCBANG DOTA_LobbyMemberXPBonus = 5 +) + +var DOTA_LobbyMemberXPBonus_name = map[int32]string{ + 0: "DOTA_LobbyMemberXPBonus_DEFAULT", + 1: "DOTA_LobbyMemberXPBonus_BATTLE_BOOSTER", + 2: "DOTA_LobbyMemberXPBonus_SHARE_BONUS", + 3: "DOTA_LobbyMemberXPBonus_PARTY", + 4: "DOTA_LobbyMemberXPBonus_RECRUITMENT", + 5: "DOTA_LobbyMemberXPBonus_PCBANG", +} +var DOTA_LobbyMemberXPBonus_value = map[string]int32{ + "DOTA_LobbyMemberXPBonus_DEFAULT": 0, + "DOTA_LobbyMemberXPBonus_BATTLE_BOOSTER": 1, + "DOTA_LobbyMemberXPBonus_SHARE_BONUS": 2, + "DOTA_LobbyMemberXPBonus_PARTY": 3, + "DOTA_LobbyMemberXPBonus_RECRUITMENT": 4, + "DOTA_LobbyMemberXPBonus_PCBANG": 5, +} + +func (x DOTA_LobbyMemberXPBonus) Enum() *DOTA_LobbyMemberXPBonus { + p := new(DOTA_LobbyMemberXPBonus) + *p = x + return p +} +func (x DOTA_LobbyMemberXPBonus) String() string { + return proto.EnumName(DOTA_LobbyMemberXPBonus_name, int32(x)) +} +func (x *DOTA_LobbyMemberXPBonus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_LobbyMemberXPBonus_value, data, "DOTA_LobbyMemberXPBonus") + if err != nil { + return err + } + *x = DOTA_LobbyMemberXPBonus(value) + return nil +} +func (DOTA_LobbyMemberXPBonus) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{14} } + +type DOTALobbyVisibility int32 + +const ( + DOTALobbyVisibility_DOTALobbyVisibility_Public DOTALobbyVisibility = 0 + DOTALobbyVisibility_DOTALobbyVisibility_Friends DOTALobbyVisibility = 1 + DOTALobbyVisibility_DOTALobbyVisibility_Unlisted DOTALobbyVisibility = 2 +) + +var DOTALobbyVisibility_name = map[int32]string{ + 0: "DOTALobbyVisibility_Public", + 1: "DOTALobbyVisibility_Friends", + 2: "DOTALobbyVisibility_Unlisted", +} +var DOTALobbyVisibility_value = map[string]int32{ + "DOTALobbyVisibility_Public": 0, + "DOTALobbyVisibility_Friends": 1, + "DOTALobbyVisibility_Unlisted": 2, +} + +func (x DOTALobbyVisibility) Enum() *DOTALobbyVisibility { + p := new(DOTALobbyVisibility) + *p = x + return p +} +func (x DOTALobbyVisibility) String() string { + return proto.EnumName(DOTALobbyVisibility_name, int32(x)) +} +func (x *DOTALobbyVisibility) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTALobbyVisibility_value, data, "DOTALobbyVisibility") + if err != nil { + return err + } + *x = DOTALobbyVisibility(value) + return nil +} +func (DOTALobbyVisibility) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{15} } + +type EDOTAPlayerMMRType int32 + +const ( + EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_Invalid EDOTAPlayerMMRType = 0 + EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_GeneralHidden EDOTAPlayerMMRType = 1 + EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_SoloHidden EDOTAPlayerMMRType = 2 + EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_GeneralCompetitive EDOTAPlayerMMRType = 3 + EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_SoloCompetitive EDOTAPlayerMMRType = 4 + EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_1v1Competitive EDOTAPlayerMMRType = 5 +) + +var EDOTAPlayerMMRType_name = map[int32]string{ + 0: "k_EDOTAPlayerMMRType_Invalid", + 1: "k_EDOTAPlayerMMRType_GeneralHidden", + 2: "k_EDOTAPlayerMMRType_SoloHidden", + 3: "k_EDOTAPlayerMMRType_GeneralCompetitive", + 4: "k_EDOTAPlayerMMRType_SoloCompetitive", + 5: "k_EDOTAPlayerMMRType_1v1Competitive", +} +var EDOTAPlayerMMRType_value = map[string]int32{ + "k_EDOTAPlayerMMRType_Invalid": 0, + "k_EDOTAPlayerMMRType_GeneralHidden": 1, + "k_EDOTAPlayerMMRType_SoloHidden": 2, + "k_EDOTAPlayerMMRType_GeneralCompetitive": 3, + "k_EDOTAPlayerMMRType_SoloCompetitive": 4, + "k_EDOTAPlayerMMRType_1v1Competitive": 5, +} + +func (x EDOTAPlayerMMRType) Enum() *EDOTAPlayerMMRType { + p := new(EDOTAPlayerMMRType) + *p = x + return p +} +func (x EDOTAPlayerMMRType) String() string { + return proto.EnumName(EDOTAPlayerMMRType_name, int32(x)) +} +func (x *EDOTAPlayerMMRType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EDOTAPlayerMMRType_value, data, "EDOTAPlayerMMRType") + if err != nil { + return err + } + *x = EDOTAPlayerMMRType(value) + return nil +} +func (EDOTAPlayerMMRType) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{16} } + +type MatchType int32 + +const ( + MatchType_MATCH_TYPE_CASUAL MatchType = 0 + MatchType_MATCH_TYPE_COOP_BOTS MatchType = 1 + MatchType_MATCH_TYPE_TEAM_RANKED MatchType = 2 + MatchType_MATCH_TYPE_LEGACY_SOLO_QUEUE MatchType = 3 + MatchType_MATCH_TYPE_COMPETITIVE MatchType = 4 + MatchType_MATCH_TYPE_WEEKEND_TOURNEY MatchType = 5 + MatchType_MATCH_TYPE_CASUAL_1V1 MatchType = 6 + MatchType_MATCH_TYPE_EVENT MatchType = 7 +) + +var MatchType_name = map[int32]string{ + 0: "MATCH_TYPE_CASUAL", + 1: "MATCH_TYPE_COOP_BOTS", + 2: "MATCH_TYPE_TEAM_RANKED", + 3: "MATCH_TYPE_LEGACY_SOLO_QUEUE", + 4: "MATCH_TYPE_COMPETITIVE", + 5: "MATCH_TYPE_WEEKEND_TOURNEY", + 6: "MATCH_TYPE_CASUAL_1V1", + 7: "MATCH_TYPE_EVENT", +} +var MatchType_value = map[string]int32{ + "MATCH_TYPE_CASUAL": 0, + "MATCH_TYPE_COOP_BOTS": 1, + "MATCH_TYPE_TEAM_RANKED": 2, + "MATCH_TYPE_LEGACY_SOLO_QUEUE": 3, + "MATCH_TYPE_COMPETITIVE": 4, + "MATCH_TYPE_WEEKEND_TOURNEY": 5, + "MATCH_TYPE_CASUAL_1V1": 6, + "MATCH_TYPE_EVENT": 7, +} + +func (x MatchType) Enum() *MatchType { + p := new(MatchType) + *p = x + return p +} +func (x MatchType) String() string { + return proto.EnumName(MatchType_name, int32(x)) +} +func (x *MatchType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MatchType_value, data, "MatchType") + if err != nil { + return err + } + *x = MatchType(value) + return nil +} +func (MatchType) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{17} } + +type DOTABotDifficulty int32 + +const ( + DOTABotDifficulty_BOT_DIFFICULTY_PASSIVE DOTABotDifficulty = 0 + DOTABotDifficulty_BOT_DIFFICULTY_EASY DOTABotDifficulty = 1 + DOTABotDifficulty_BOT_DIFFICULTY_MEDIUM DOTABotDifficulty = 2 + DOTABotDifficulty_BOT_DIFFICULTY_HARD DOTABotDifficulty = 3 + DOTABotDifficulty_BOT_DIFFICULTY_UNFAIR DOTABotDifficulty = 4 + DOTABotDifficulty_BOT_DIFFICULTY_INVALID DOTABotDifficulty = 5 + DOTABotDifficulty_BOT_DIFFICULTY_EXTRA1 DOTABotDifficulty = 6 + DOTABotDifficulty_BOT_DIFFICULTY_EXTRA2 DOTABotDifficulty = 7 + DOTABotDifficulty_BOT_DIFFICULTY_EXTRA3 DOTABotDifficulty = 8 +) + +var DOTABotDifficulty_name = map[int32]string{ + 0: "BOT_DIFFICULTY_PASSIVE", + 1: "BOT_DIFFICULTY_EASY", + 2: "BOT_DIFFICULTY_MEDIUM", + 3: "BOT_DIFFICULTY_HARD", + 4: "BOT_DIFFICULTY_UNFAIR", + 5: "BOT_DIFFICULTY_INVALID", + 6: "BOT_DIFFICULTY_EXTRA1", + 7: "BOT_DIFFICULTY_EXTRA2", + 8: "BOT_DIFFICULTY_EXTRA3", +} +var DOTABotDifficulty_value = map[string]int32{ + "BOT_DIFFICULTY_PASSIVE": 0, + "BOT_DIFFICULTY_EASY": 1, + "BOT_DIFFICULTY_MEDIUM": 2, + "BOT_DIFFICULTY_HARD": 3, + "BOT_DIFFICULTY_UNFAIR": 4, + "BOT_DIFFICULTY_INVALID": 5, + "BOT_DIFFICULTY_EXTRA1": 6, + "BOT_DIFFICULTY_EXTRA2": 7, + "BOT_DIFFICULTY_EXTRA3": 8, +} + +func (x DOTABotDifficulty) Enum() *DOTABotDifficulty { + p := new(DOTABotDifficulty) + *p = x + return p +} +func (x DOTABotDifficulty) String() string { + return proto.EnumName(DOTABotDifficulty_name, int32(x)) +} +func (x *DOTABotDifficulty) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTABotDifficulty_value, data, "DOTABotDifficulty") + if err != nil { + return err + } + *x = DOTABotDifficulty(value) + return nil +} +func (DOTABotDifficulty) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{18} } + +type MatchLanguages int32 + +const ( + MatchLanguages_MATCH_LANGUAGE_INVALID MatchLanguages = 0 + MatchLanguages_MATCH_LANGUAGE_ENGLISH MatchLanguages = 1 + MatchLanguages_MATCH_LANGUAGE_RUSSIAN MatchLanguages = 2 + MatchLanguages_MATCH_LANGUAGE_CHINESE MatchLanguages = 3 + MatchLanguages_MATCH_LANGUAGE_KOREAN MatchLanguages = 4 + MatchLanguages_MATCH_LANGUAGE_SPANISH MatchLanguages = 5 + MatchLanguages_MATCH_LANGUAGE_PORTUGUESE MatchLanguages = 6 + MatchLanguages_MATCH_LANGUAGE_ENGLISH2 MatchLanguages = 7 +) + +var MatchLanguages_name = map[int32]string{ + 0: "MATCH_LANGUAGE_INVALID", + 1: "MATCH_LANGUAGE_ENGLISH", + 2: "MATCH_LANGUAGE_RUSSIAN", + 3: "MATCH_LANGUAGE_CHINESE", + 4: "MATCH_LANGUAGE_KOREAN", + 5: "MATCH_LANGUAGE_SPANISH", + 6: "MATCH_LANGUAGE_PORTUGUESE", + 7: "MATCH_LANGUAGE_ENGLISH2", +} +var MatchLanguages_value = map[string]int32{ + "MATCH_LANGUAGE_INVALID": 0, + "MATCH_LANGUAGE_ENGLISH": 1, + "MATCH_LANGUAGE_RUSSIAN": 2, + "MATCH_LANGUAGE_CHINESE": 3, + "MATCH_LANGUAGE_KOREAN": 4, + "MATCH_LANGUAGE_SPANISH": 5, + "MATCH_LANGUAGE_PORTUGUESE": 6, + "MATCH_LANGUAGE_ENGLISH2": 7, +} + +func (x MatchLanguages) Enum() *MatchLanguages { + p := new(MatchLanguages) + *p = x + return p +} +func (x MatchLanguages) String() string { + return proto.EnumName(MatchLanguages_name, int32(x)) +} +func (x *MatchLanguages) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MatchLanguages_value, data, "MatchLanguages") + if err != nil { + return err + } + *x = MatchLanguages(value) + return nil +} +func (MatchLanguages) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{19} } + +type ETournamentTemplate int32 + +const ( + ETournamentTemplate_k_ETournamentTemplate_None ETournamentTemplate = 0 + ETournamentTemplate_k_ETournamentTemplate_SingleElimination ETournamentTemplate = 1 +) + +var ETournamentTemplate_name = map[int32]string{ + 0: "k_ETournamentTemplate_None", + 1: "k_ETournamentTemplate_SingleElimination", +} +var ETournamentTemplate_value = map[string]int32{ + "k_ETournamentTemplate_None": 0, + "k_ETournamentTemplate_SingleElimination": 1, +} + +func (x ETournamentTemplate) Enum() *ETournamentTemplate { + p := new(ETournamentTemplate) + *p = x + return p +} +func (x ETournamentTemplate) String() string { + return proto.EnumName(ETournamentTemplate_name, int32(x)) +} +func (x *ETournamentTemplate) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ETournamentTemplate_value, data, "ETournamentTemplate") + if err != nil { + return err + } + *x = ETournamentTemplate(value) + return nil +} +func (ETournamentTemplate) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{20} } + +type ETournamentType int32 + +const ( + ETournamentType_k_ETournamentType_Unknown ETournamentType = 0 + ETournamentType_k_ETournamentType_WeeklyDivision ETournamentType = 1 +) + +var ETournamentType_name = map[int32]string{ + 0: "k_ETournamentType_Unknown", + 1: "k_ETournamentType_WeeklyDivision", +} +var ETournamentType_value = map[string]int32{ + "k_ETournamentType_Unknown": 0, + "k_ETournamentType_WeeklyDivision": 1, +} + +func (x ETournamentType) Enum() *ETournamentType { + p := new(ETournamentType) + *p = x + return p +} +func (x ETournamentType) String() string { + return proto.EnumName(ETournamentType_name, int32(x)) +} +func (x *ETournamentType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ETournamentType_value, data, "ETournamentType") + if err != nil { + return err + } + *x = ETournamentType(value) + return nil +} +func (ETournamentType) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{21} } + +type EEvent int32 + +const ( + EEvent_EVENT_ID_NONE EEvent = 0 + EEvent_EVENT_ID_DIRETIDE EEvent = 1 + EEvent_EVENT_ID_SPRING_FESTIVAL EEvent = 2 + EEvent_EVENT_ID_FROSTIVUS_2013 EEvent = 3 + EEvent_EVENT_ID_COMPENDIUM_2014 EEvent = 4 + EEvent_EVENT_ID_NEXON_PC_BANG EEvent = 5 + EEvent_EVENT_ID_PWRD_DAC_2015 EEvent = 6 + EEvent_EVENT_ID_NEW_BLOOM_2015 EEvent = 7 + EEvent_EVENT_ID_INTERNATIONAL_2015 EEvent = 8 + EEvent_EVENT_ID_FALL_MAJOR_2015 EEvent = 9 + EEvent_EVENT_ID_ORACLE_PA EEvent = 10 + EEvent_EVENT_ID_NEW_BLOOM_2015_PREBEAST EEvent = 11 + EEvent_EVENT_ID_FROSTIVUS EEvent = 12 + EEvent_EVENT_ID_WINTER_MAJOR_2015 EEvent = 13 +) + +var EEvent_name = map[int32]string{ + 0: "EVENT_ID_NONE", + 1: "EVENT_ID_DIRETIDE", + 2: "EVENT_ID_SPRING_FESTIVAL", + 3: "EVENT_ID_FROSTIVUS_2013", + 4: "EVENT_ID_COMPENDIUM_2014", + 5: "EVENT_ID_NEXON_PC_BANG", + 6: "EVENT_ID_PWRD_DAC_2015", + 7: "EVENT_ID_NEW_BLOOM_2015", + 8: "EVENT_ID_INTERNATIONAL_2015", + 9: "EVENT_ID_FALL_MAJOR_2015", + 10: "EVENT_ID_ORACLE_PA", + 11: "EVENT_ID_NEW_BLOOM_2015_PREBEAST", + 12: "EVENT_ID_FROSTIVUS", + 13: "EVENT_ID_WINTER_MAJOR_2015", +} +var EEvent_value = map[string]int32{ + "EVENT_ID_NONE": 0, + "EVENT_ID_DIRETIDE": 1, + "EVENT_ID_SPRING_FESTIVAL": 2, + "EVENT_ID_FROSTIVUS_2013": 3, + "EVENT_ID_COMPENDIUM_2014": 4, + "EVENT_ID_NEXON_PC_BANG": 5, + "EVENT_ID_PWRD_DAC_2015": 6, + "EVENT_ID_NEW_BLOOM_2015": 7, + "EVENT_ID_INTERNATIONAL_2015": 8, + "EVENT_ID_FALL_MAJOR_2015": 9, + "EVENT_ID_ORACLE_PA": 10, + "EVENT_ID_NEW_BLOOM_2015_PREBEAST": 11, + "EVENT_ID_FROSTIVUS": 12, + "EVENT_ID_WINTER_MAJOR_2015": 13, +} + +func (x EEvent) Enum() *EEvent { + p := new(EEvent) + *p = x + return p +} +func (x EEvent) String() string { + return proto.EnumName(EEvent_name, int32(x)) +} +func (x *EEvent) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EEvent_value, data, "EEvent") + if err != nil { + return err + } + *x = EEvent(value) + return nil +} +func (EEvent) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{22} } + +type LobbyDotaTVDelay int32 + +const ( + LobbyDotaTVDelay_LobbyDotaTV_10 LobbyDotaTVDelay = 0 + LobbyDotaTVDelay_LobbyDotaTV_120 LobbyDotaTVDelay = 1 + LobbyDotaTVDelay_LobbyDotaTV_300 LobbyDotaTVDelay = 2 +) + +var LobbyDotaTVDelay_name = map[int32]string{ + 0: "LobbyDotaTV_10", + 1: "LobbyDotaTV_120", + 2: "LobbyDotaTV_300", +} +var LobbyDotaTVDelay_value = map[string]int32{ + "LobbyDotaTV_10": 0, + "LobbyDotaTV_120": 1, + "LobbyDotaTV_300": 2, +} + +func (x LobbyDotaTVDelay) Enum() *LobbyDotaTVDelay { + p := new(LobbyDotaTVDelay) + *p = x + return p +} +func (x LobbyDotaTVDelay) String() string { + return proto.EnumName(LobbyDotaTVDelay_name, int32(x)) +} +func (x *LobbyDotaTVDelay) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(LobbyDotaTVDelay_value, data, "LobbyDotaTVDelay") + if err != nil { + return err + } + *x = LobbyDotaTVDelay(value) + return nil +} +func (LobbyDotaTVDelay) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{23} } + +type LobbyDotaPauseSetting int32 + +const ( + LobbyDotaPauseSetting_LobbyDotaPauseSetting_Unlimited LobbyDotaPauseSetting = 0 + LobbyDotaPauseSetting_LobbyDotaPauseSetting_Limited LobbyDotaPauseSetting = 1 + LobbyDotaPauseSetting_LobbyDotaPauseSetting_Disabled LobbyDotaPauseSetting = 2 +) + +var LobbyDotaPauseSetting_name = map[int32]string{ + 0: "LobbyDotaPauseSetting_Unlimited", + 1: "LobbyDotaPauseSetting_Limited", + 2: "LobbyDotaPauseSetting_Disabled", +} +var LobbyDotaPauseSetting_value = map[string]int32{ + "LobbyDotaPauseSetting_Unlimited": 0, + "LobbyDotaPauseSetting_Limited": 1, + "LobbyDotaPauseSetting_Disabled": 2, +} + +func (x LobbyDotaPauseSetting) Enum() *LobbyDotaPauseSetting { + p := new(LobbyDotaPauseSetting) + *p = x + return p +} +func (x LobbyDotaPauseSetting) String() string { + return proto.EnumName(LobbyDotaPauseSetting_name, int32(x)) +} +func (x *LobbyDotaPauseSetting) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(LobbyDotaPauseSetting_value, data, "LobbyDotaPauseSetting") + if err != nil { + return err + } + *x = LobbyDotaPauseSetting(value) + return nil +} +func (LobbyDotaPauseSetting) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{24} } + +type EMatchOutcome int32 + +const ( + EMatchOutcome_k_EMatchOutcome_Unknown EMatchOutcome = 0 + EMatchOutcome_k_EMatchOutcome_RadVictory EMatchOutcome = 2 + EMatchOutcome_k_EMatchOutcome_DireVictory EMatchOutcome = 3 + EMatchOutcome_k_EMatchOutcome_NotScored_PoorNetworkConditions EMatchOutcome = 64 + EMatchOutcome_k_EMatchOutcome_NotScored_Leaver EMatchOutcome = 65 + EMatchOutcome_k_EMatchOutcome_NotScored_ServerCrash EMatchOutcome = 66 + EMatchOutcome_k_EMatchOutcome_NotScored_NeverStarted EMatchOutcome = 67 +) + +var EMatchOutcome_name = map[int32]string{ + 0: "k_EMatchOutcome_Unknown", + 2: "k_EMatchOutcome_RadVictory", + 3: "k_EMatchOutcome_DireVictory", + 64: "k_EMatchOutcome_NotScored_PoorNetworkConditions", + 65: "k_EMatchOutcome_NotScored_Leaver", + 66: "k_EMatchOutcome_NotScored_ServerCrash", + 67: "k_EMatchOutcome_NotScored_NeverStarted", +} +var EMatchOutcome_value = map[string]int32{ + "k_EMatchOutcome_Unknown": 0, + "k_EMatchOutcome_RadVictory": 2, + "k_EMatchOutcome_DireVictory": 3, + "k_EMatchOutcome_NotScored_PoorNetworkConditions": 64, + "k_EMatchOutcome_NotScored_Leaver": 65, + "k_EMatchOutcome_NotScored_ServerCrash": 66, + "k_EMatchOutcome_NotScored_NeverStarted": 67, +} + +func (x EMatchOutcome) Enum() *EMatchOutcome { + p := new(EMatchOutcome) + *p = x + return p +} +func (x EMatchOutcome) String() string { + return proto.EnumName(EMatchOutcome_name, int32(x)) +} +func (x *EMatchOutcome) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EMatchOutcome_value, data, "EMatchOutcome") + if err != nil { + return err + } + *x = EMatchOutcome(value) + return nil +} +func (EMatchOutcome) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{25} } + +type EDOTAGCSessionNeed int32 + +const ( + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_Unknown EDOTAGCSessionNeed = 0 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserNoSessionNeeded EDOTAGCSessionNeed = 100 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserInOnlineGame EDOTAGCSessionNeed = 101 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserInLocalGame EDOTAGCSessionNeed = 102 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserInUIWasConnected EDOTAGCSessionNeed = 103 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserInUINeverConnected EDOTAGCSessionNeed = 104 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserTutorials EDOTAGCSessionNeed = 105 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserInUIWasConnectedIdle EDOTAGCSessionNeed = 106 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_UserInUINeverConnectedIdle EDOTAGCSessionNeed = 107 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_GameServerOnline EDOTAGCSessionNeed = 200 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_GameServerLocal EDOTAGCSessionNeed = 201 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_GameServerIdle EDOTAGCSessionNeed = 202 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_GameServerRelay EDOTAGCSessionNeed = 203 + EDOTAGCSessionNeed_k_EDOTAGCSessionNeed_GameServerLocalUpload EDOTAGCSessionNeed = 204 +) + +var EDOTAGCSessionNeed_name = map[int32]string{ + 0: "k_EDOTAGCSessionNeed_Unknown", + 100: "k_EDOTAGCSessionNeed_UserNoSessionNeeded", + 101: "k_EDOTAGCSessionNeed_UserInOnlineGame", + 102: "k_EDOTAGCSessionNeed_UserInLocalGame", + 103: "k_EDOTAGCSessionNeed_UserInUIWasConnected", + 104: "k_EDOTAGCSessionNeed_UserInUINeverConnected", + 105: "k_EDOTAGCSessionNeed_UserTutorials", + 106: "k_EDOTAGCSessionNeed_UserInUIWasConnectedIdle", + 107: "k_EDOTAGCSessionNeed_UserInUINeverConnectedIdle", + 200: "k_EDOTAGCSessionNeed_GameServerOnline", + 201: "k_EDOTAGCSessionNeed_GameServerLocal", + 202: "k_EDOTAGCSessionNeed_GameServerIdle", + 203: "k_EDOTAGCSessionNeed_GameServerRelay", + 204: "k_EDOTAGCSessionNeed_GameServerLocalUpload", +} +var EDOTAGCSessionNeed_value = map[string]int32{ + "k_EDOTAGCSessionNeed_Unknown": 0, + "k_EDOTAGCSessionNeed_UserNoSessionNeeded": 100, + "k_EDOTAGCSessionNeed_UserInOnlineGame": 101, + "k_EDOTAGCSessionNeed_UserInLocalGame": 102, + "k_EDOTAGCSessionNeed_UserInUIWasConnected": 103, + "k_EDOTAGCSessionNeed_UserInUINeverConnected": 104, + "k_EDOTAGCSessionNeed_UserTutorials": 105, + "k_EDOTAGCSessionNeed_UserInUIWasConnectedIdle": 106, + "k_EDOTAGCSessionNeed_UserInUINeverConnectedIdle": 107, + "k_EDOTAGCSessionNeed_GameServerOnline": 200, + "k_EDOTAGCSessionNeed_GameServerLocal": 201, + "k_EDOTAGCSessionNeed_GameServerIdle": 202, + "k_EDOTAGCSessionNeed_GameServerRelay": 203, + "k_EDOTAGCSessionNeed_GameServerLocalUpload": 204, +} + +func (x EDOTAGCSessionNeed) Enum() *EDOTAGCSessionNeed { + p := new(EDOTAGCSessionNeed) + *p = x + return p +} +func (x EDOTAGCSessionNeed) String() string { + return proto.EnumName(EDOTAGCSessionNeed_name, int32(x)) +} +func (x *EDOTAGCSessionNeed) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EDOTAGCSessionNeed_value, data, "EDOTAGCSessionNeed") + if err != nil { + return err + } + *x = EDOTAGCSessionNeed(value) + return nil +} +func (EDOTAGCSessionNeed) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{26} } + +type Fantasy_Roles int32 + +const ( + Fantasy_Roles_FANTASY_ROLE_UNDEFINED Fantasy_Roles = 0 + Fantasy_Roles_FANTASY_ROLE_CORE Fantasy_Roles = 1 + Fantasy_Roles_FANTASY_ROLE_SUPPORT Fantasy_Roles = 2 +) + +var Fantasy_Roles_name = map[int32]string{ + 0: "FANTASY_ROLE_UNDEFINED", + 1: "FANTASY_ROLE_CORE", + 2: "FANTASY_ROLE_SUPPORT", +} +var Fantasy_Roles_value = map[string]int32{ + "FANTASY_ROLE_UNDEFINED": 0, + "FANTASY_ROLE_CORE": 1, + "FANTASY_ROLE_SUPPORT": 2, +} + +func (x Fantasy_Roles) Enum() *Fantasy_Roles { + p := new(Fantasy_Roles) + *p = x + return p +} +func (x Fantasy_Roles) String() string { + return proto.EnumName(Fantasy_Roles_name, int32(x)) +} +func (x *Fantasy_Roles) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Fantasy_Roles_value, data, "Fantasy_Roles") + if err != nil { + return err + } + *x = Fantasy_Roles(value) + return nil +} +func (Fantasy_Roles) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{27} } + +type Fantasy_Team_Slots int32 + +const ( + Fantasy_Team_Slots_FANTASY_SLOT_NONE Fantasy_Team_Slots = 0 + Fantasy_Team_Slots_FANTASY_SLOT_CORE Fantasy_Team_Slots = 1 + Fantasy_Team_Slots_FANTASY_SLOT_SUPPORT Fantasy_Team_Slots = 2 + Fantasy_Team_Slots_FANTASY_SLOT_ANY Fantasy_Team_Slots = 3 + Fantasy_Team_Slots_FANTASY_SLOT_BENCH Fantasy_Team_Slots = 4 +) + +var Fantasy_Team_Slots_name = map[int32]string{ + 0: "FANTASY_SLOT_NONE", + 1: "FANTASY_SLOT_CORE", + 2: "FANTASY_SLOT_SUPPORT", + 3: "FANTASY_SLOT_ANY", + 4: "FANTASY_SLOT_BENCH", +} +var Fantasy_Team_Slots_value = map[string]int32{ + "FANTASY_SLOT_NONE": 0, + "FANTASY_SLOT_CORE": 1, + "FANTASY_SLOT_SUPPORT": 2, + "FANTASY_SLOT_ANY": 3, + "FANTASY_SLOT_BENCH": 4, +} + +func (x Fantasy_Team_Slots) Enum() *Fantasy_Team_Slots { + p := new(Fantasy_Team_Slots) + *p = x + return p +} +func (x Fantasy_Team_Slots) String() string { + return proto.EnumName(Fantasy_Team_Slots_name, int32(x)) +} +func (x *Fantasy_Team_Slots) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Fantasy_Team_Slots_value, data, "Fantasy_Team_Slots") + if err != nil { + return err + } + *x = Fantasy_Team_Slots(value) + return nil +} +func (Fantasy_Team_Slots) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{28} } + +type Fantasy_Selection_Mode int32 + +const ( + Fantasy_Selection_Mode_FANTASY_SELECTION_INVALID Fantasy_Selection_Mode = 0 + Fantasy_Selection_Mode_FANTASY_SELECTION_LOCKED Fantasy_Selection_Mode = 1 + Fantasy_Selection_Mode_FANTASY_SELECTION_SHUFFLE Fantasy_Selection_Mode = 2 + Fantasy_Selection_Mode_FANTASY_SELECTION_FREE_PICK Fantasy_Selection_Mode = 3 + Fantasy_Selection_Mode_FANTASY_SELECTION_ENDED Fantasy_Selection_Mode = 4 + Fantasy_Selection_Mode_FANTASY_SELECTION_PRE_SEASON Fantasy_Selection_Mode = 5 + Fantasy_Selection_Mode_FANTASY_SELECTION_PRE_DRAFT Fantasy_Selection_Mode = 6 + Fantasy_Selection_Mode_FANTASY_SELECTION_DRAFTING Fantasy_Selection_Mode = 7 + Fantasy_Selection_Mode_FANTASY_SELECTION_REGULAR_SEASON Fantasy_Selection_Mode = 8 +) + +var Fantasy_Selection_Mode_name = map[int32]string{ + 0: "FANTASY_SELECTION_INVALID", + 1: "FANTASY_SELECTION_LOCKED", + 2: "FANTASY_SELECTION_SHUFFLE", + 3: "FANTASY_SELECTION_FREE_PICK", + 4: "FANTASY_SELECTION_ENDED", + 5: "FANTASY_SELECTION_PRE_SEASON", + 6: "FANTASY_SELECTION_PRE_DRAFT", + 7: "FANTASY_SELECTION_DRAFTING", + 8: "FANTASY_SELECTION_REGULAR_SEASON", +} +var Fantasy_Selection_Mode_value = map[string]int32{ + "FANTASY_SELECTION_INVALID": 0, + "FANTASY_SELECTION_LOCKED": 1, + "FANTASY_SELECTION_SHUFFLE": 2, + "FANTASY_SELECTION_FREE_PICK": 3, + "FANTASY_SELECTION_ENDED": 4, + "FANTASY_SELECTION_PRE_SEASON": 5, + "FANTASY_SELECTION_PRE_DRAFT": 6, + "FANTASY_SELECTION_DRAFTING": 7, + "FANTASY_SELECTION_REGULAR_SEASON": 8, +} + +func (x Fantasy_Selection_Mode) Enum() *Fantasy_Selection_Mode { + p := new(Fantasy_Selection_Mode) + *p = x + return p +} +func (x Fantasy_Selection_Mode) String() string { + return proto.EnumName(Fantasy_Selection_Mode_name, int32(x)) +} +func (x *Fantasy_Selection_Mode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Fantasy_Selection_Mode_value, data, "Fantasy_Selection_Mode") + if err != nil { + return err + } + *x = Fantasy_Selection_Mode(value) + return nil +} +func (Fantasy_Selection_Mode) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{29} } + +type DOTA_TournamentEvents int32 + +const ( + DOTA_TournamentEvents_TE_FIRST_BLOOD DOTA_TournamentEvents = 0 + DOTA_TournamentEvents_TE_GAME_END DOTA_TournamentEvents = 1 + DOTA_TournamentEvents_TE_MULTI_KILL DOTA_TournamentEvents = 2 + DOTA_TournamentEvents_TE_HERO_DENY DOTA_TournamentEvents = 3 + DOTA_TournamentEvents_TE_AEGIS_DENY DOTA_TournamentEvents = 4 + DOTA_TournamentEvents_TE_AEGIS_STOLEN DOTA_TournamentEvents = 5 + DOTA_TournamentEvents_TE_GODLIKE DOTA_TournamentEvents = 6 + DOTA_TournamentEvents_TE_COURIER_KILL DOTA_TournamentEvents = 7 + DOTA_TournamentEvents_TE_ECHOSLAM DOTA_TournamentEvents = 8 + DOTA_TournamentEvents_TE_RAPIER DOTA_TournamentEvents = 9 + DOTA_TournamentEvents_TE_EARLY_ROSHAN DOTA_TournamentEvents = 10 + DOTA_TournamentEvents_TE_BLACK_HOLE DOTA_TournamentEvents = 11 +) + +var DOTA_TournamentEvents_name = map[int32]string{ + 0: "TE_FIRST_BLOOD", + 1: "TE_GAME_END", + 2: "TE_MULTI_KILL", + 3: "TE_HERO_DENY", + 4: "TE_AEGIS_DENY", + 5: "TE_AEGIS_STOLEN", + 6: "TE_GODLIKE", + 7: "TE_COURIER_KILL", + 8: "TE_ECHOSLAM", + 9: "TE_RAPIER", + 10: "TE_EARLY_ROSHAN", + 11: "TE_BLACK_HOLE", +} +var DOTA_TournamentEvents_value = map[string]int32{ + "TE_FIRST_BLOOD": 0, + "TE_GAME_END": 1, + "TE_MULTI_KILL": 2, + "TE_HERO_DENY": 3, + "TE_AEGIS_DENY": 4, + "TE_AEGIS_STOLEN": 5, + "TE_GODLIKE": 6, + "TE_COURIER_KILL": 7, + "TE_ECHOSLAM": 8, + "TE_RAPIER": 9, + "TE_EARLY_ROSHAN": 10, + "TE_BLACK_HOLE": 11, +} + +func (x DOTA_TournamentEvents) Enum() *DOTA_TournamentEvents { + p := new(DOTA_TournamentEvents) + *p = x + return p +} +func (x DOTA_TournamentEvents) String() string { + return proto.EnumName(DOTA_TournamentEvents_name, int32(x)) +} +func (x *DOTA_TournamentEvents) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_TournamentEvents_value, data, "DOTA_TournamentEvents") + if err != nil { + return err + } + *x = DOTA_TournamentEvents(value) + return nil +} +func (DOTA_TournamentEvents) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{30} } + +type DOTA_COMBATLOG_TYPES int32 + +const ( + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_DAMAGE DOTA_COMBATLOG_TYPES = 0 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_HEAL DOTA_COMBATLOG_TYPES = 1 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_MODIFIER_ADD DOTA_COMBATLOG_TYPES = 2 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_MODIFIER_REMOVE DOTA_COMBATLOG_TYPES = 3 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_DEATH DOTA_COMBATLOG_TYPES = 4 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_ABILITY DOTA_COMBATLOG_TYPES = 5 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_ITEM DOTA_COMBATLOG_TYPES = 6 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_LOCATION DOTA_COMBATLOG_TYPES = 7 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_GOLD DOTA_COMBATLOG_TYPES = 8 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_GAME_STATE DOTA_COMBATLOG_TYPES = 9 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_XP DOTA_COMBATLOG_TYPES = 10 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_PURCHASE DOTA_COMBATLOG_TYPES = 11 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_BUYBACK DOTA_COMBATLOG_TYPES = 12 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_ABILITY_TRIGGER DOTA_COMBATLOG_TYPES = 13 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_PLAYERSTATS DOTA_COMBATLOG_TYPES = 14 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_MULTIKILL DOTA_COMBATLOG_TYPES = 15 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_KILLSTREAK DOTA_COMBATLOG_TYPES = 16 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_TEAM_BUILDING_KILL DOTA_COMBATLOG_TYPES = 17 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_FIRST_BLOOD DOTA_COMBATLOG_TYPES = 18 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_MODIFIER_REFRESH DOTA_COMBATLOG_TYPES = 19 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_NEUTRAL_CAMP_STACK DOTA_COMBATLOG_TYPES = 20 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_PICKUP_RUNE DOTA_COMBATLOG_TYPES = 21 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_REVEALED_INVISIBLE DOTA_COMBATLOG_TYPES = 22 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_HERO_SAVED DOTA_COMBATLOG_TYPES = 23 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_MANA_RESTORED DOTA_COMBATLOG_TYPES = 24 + DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_HERO_LEVELUP DOTA_COMBATLOG_TYPES = 25 +) + +var DOTA_COMBATLOG_TYPES_name = map[int32]string{ + 0: "DOTA_COMBATLOG_DAMAGE", + 1: "DOTA_COMBATLOG_HEAL", + 2: "DOTA_COMBATLOG_MODIFIER_ADD", + 3: "DOTA_COMBATLOG_MODIFIER_REMOVE", + 4: "DOTA_COMBATLOG_DEATH", + 5: "DOTA_COMBATLOG_ABILITY", + 6: "DOTA_COMBATLOG_ITEM", + 7: "DOTA_COMBATLOG_LOCATION", + 8: "DOTA_COMBATLOG_GOLD", + 9: "DOTA_COMBATLOG_GAME_STATE", + 10: "DOTA_COMBATLOG_XP", + 11: "DOTA_COMBATLOG_PURCHASE", + 12: "DOTA_COMBATLOG_BUYBACK", + 13: "DOTA_COMBATLOG_ABILITY_TRIGGER", + 14: "DOTA_COMBATLOG_PLAYERSTATS", + 15: "DOTA_COMBATLOG_MULTIKILL", + 16: "DOTA_COMBATLOG_KILLSTREAK", + 17: "DOTA_COMBATLOG_TEAM_BUILDING_KILL", + 18: "DOTA_COMBATLOG_FIRST_BLOOD", + 19: "DOTA_COMBATLOG_MODIFIER_REFRESH", + 20: "DOTA_COMBATLOG_NEUTRAL_CAMP_STACK", + 21: "DOTA_COMBATLOG_PICKUP_RUNE", + 22: "DOTA_COMBATLOG_REVEALED_INVISIBLE", + 23: "DOTA_COMBATLOG_HERO_SAVED", + 24: "DOTA_COMBATLOG_MANA_RESTORED", + 25: "DOTA_COMBATLOG_HERO_LEVELUP", +} +var DOTA_COMBATLOG_TYPES_value = map[string]int32{ + "DOTA_COMBATLOG_DAMAGE": 0, + "DOTA_COMBATLOG_HEAL": 1, + "DOTA_COMBATLOG_MODIFIER_ADD": 2, + "DOTA_COMBATLOG_MODIFIER_REMOVE": 3, + "DOTA_COMBATLOG_DEATH": 4, + "DOTA_COMBATLOG_ABILITY": 5, + "DOTA_COMBATLOG_ITEM": 6, + "DOTA_COMBATLOG_LOCATION": 7, + "DOTA_COMBATLOG_GOLD": 8, + "DOTA_COMBATLOG_GAME_STATE": 9, + "DOTA_COMBATLOG_XP": 10, + "DOTA_COMBATLOG_PURCHASE": 11, + "DOTA_COMBATLOG_BUYBACK": 12, + "DOTA_COMBATLOG_ABILITY_TRIGGER": 13, + "DOTA_COMBATLOG_PLAYERSTATS": 14, + "DOTA_COMBATLOG_MULTIKILL": 15, + "DOTA_COMBATLOG_KILLSTREAK": 16, + "DOTA_COMBATLOG_TEAM_BUILDING_KILL": 17, + "DOTA_COMBATLOG_FIRST_BLOOD": 18, + "DOTA_COMBATLOG_MODIFIER_REFRESH": 19, + "DOTA_COMBATLOG_NEUTRAL_CAMP_STACK": 20, + "DOTA_COMBATLOG_PICKUP_RUNE": 21, + "DOTA_COMBATLOG_REVEALED_INVISIBLE": 22, + "DOTA_COMBATLOG_HERO_SAVED": 23, + "DOTA_COMBATLOG_MANA_RESTORED": 24, + "DOTA_COMBATLOG_HERO_LEVELUP": 25, +} + +func (x DOTA_COMBATLOG_TYPES) Enum() *DOTA_COMBATLOG_TYPES { + p := new(DOTA_COMBATLOG_TYPES) + *p = x + return p +} +func (x DOTA_COMBATLOG_TYPES) String() string { + return proto.EnumName(DOTA_COMBATLOG_TYPES_name, int32(x)) +} +func (x *DOTA_COMBATLOG_TYPES) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTA_COMBATLOG_TYPES_value, data, "DOTA_COMBATLOG_TYPES") + if err != nil { + return err + } + *x = DOTA_COMBATLOG_TYPES(value) + return nil +} +func (DOTA_COMBATLOG_TYPES) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{31} } + +type DOTAChatChannelTypeT int32 + +const ( + DOTAChatChannelTypeT_DOTAChannelType_Regional DOTAChatChannelTypeT = 0 + DOTAChatChannelTypeT_DOTAChannelType_Custom DOTAChatChannelTypeT = 1 + DOTAChatChannelTypeT_DOTAChannelType_Party DOTAChatChannelTypeT = 2 + DOTAChatChannelTypeT_DOTAChannelType_Lobby DOTAChatChannelTypeT = 3 + DOTAChatChannelTypeT_DOTAChannelType_Team DOTAChatChannelTypeT = 4 + DOTAChatChannelTypeT_DOTAChannelType_Guild DOTAChatChannelTypeT = 5 + DOTAChatChannelTypeT_DOTAChannelType_Fantasy DOTAChatChannelTypeT = 6 + DOTAChatChannelTypeT_DOTAChannelType_Whisper DOTAChatChannelTypeT = 7 + DOTAChatChannelTypeT_DOTAChannelType_Console DOTAChatChannelTypeT = 8 + DOTAChatChannelTypeT_DOTAChannelType_Tab DOTAChatChannelTypeT = 9 + DOTAChatChannelTypeT_DOTAChannelType_Invalid DOTAChatChannelTypeT = 10 + DOTAChatChannelTypeT_DOTAChannelType_GameAll DOTAChatChannelTypeT = 11 + DOTAChatChannelTypeT_DOTAChannelType_GameAllies DOTAChatChannelTypeT = 12 + DOTAChatChannelTypeT_DOTAChannelType_GameSpectator DOTAChatChannelTypeT = 13 + DOTAChatChannelTypeT_DOTAChannelType_GameCoaching DOTAChatChannelTypeT = 14 + DOTAChatChannelTypeT_DOTAChannelType_Cafe DOTAChatChannelTypeT = 15 + DOTAChatChannelTypeT_DOTAChannelType_CustomGame DOTAChatChannelTypeT = 16 + DOTAChatChannelTypeT_DOTAChannelType_Private DOTAChatChannelTypeT = 17 +) + +var DOTAChatChannelTypeT_name = map[int32]string{ + 0: "DOTAChannelType_Regional", + 1: "DOTAChannelType_Custom", + 2: "DOTAChannelType_Party", + 3: "DOTAChannelType_Lobby", + 4: "DOTAChannelType_Team", + 5: "DOTAChannelType_Guild", + 6: "DOTAChannelType_Fantasy", + 7: "DOTAChannelType_Whisper", + 8: "DOTAChannelType_Console", + 9: "DOTAChannelType_Tab", + 10: "DOTAChannelType_Invalid", + 11: "DOTAChannelType_GameAll", + 12: "DOTAChannelType_GameAllies", + 13: "DOTAChannelType_GameSpectator", + 14: "DOTAChannelType_GameCoaching", + 15: "DOTAChannelType_Cafe", + 16: "DOTAChannelType_CustomGame", + 17: "DOTAChannelType_Private", +} +var DOTAChatChannelTypeT_value = map[string]int32{ + "DOTAChannelType_Regional": 0, + "DOTAChannelType_Custom": 1, + "DOTAChannelType_Party": 2, + "DOTAChannelType_Lobby": 3, + "DOTAChannelType_Team": 4, + "DOTAChannelType_Guild": 5, + "DOTAChannelType_Fantasy": 6, + "DOTAChannelType_Whisper": 7, + "DOTAChannelType_Console": 8, + "DOTAChannelType_Tab": 9, + "DOTAChannelType_Invalid": 10, + "DOTAChannelType_GameAll": 11, + "DOTAChannelType_GameAllies": 12, + "DOTAChannelType_GameSpectator": 13, + "DOTAChannelType_GameCoaching": 14, + "DOTAChannelType_Cafe": 15, + "DOTAChannelType_CustomGame": 16, + "DOTAChannelType_Private": 17, +} + +func (x DOTAChatChannelTypeT) Enum() *DOTAChatChannelTypeT { + p := new(DOTAChatChannelTypeT) + *p = x + return p +} +func (x DOTAChatChannelTypeT) String() string { + return proto.EnumName(DOTAChatChannelTypeT_name, int32(x)) +} +func (x *DOTAChatChannelTypeT) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DOTAChatChannelTypeT_value, data, "DOTAChatChannelTypeT") + if err != nil { + return err + } + *x = DOTAChatChannelTypeT(value) + return nil +} +func (DOTAChatChannelTypeT) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{32} } + +type CSODOTAParty_State int32 + +const ( + CSODOTAParty_UI CSODOTAParty_State = 0 + CSODOTAParty_FINDING_MATCH CSODOTAParty_State = 1 + CSODOTAParty_IN_MATCH CSODOTAParty_State = 2 +) + +var CSODOTAParty_State_name = map[int32]string{ + 0: "UI", + 1: "FINDING_MATCH", + 2: "IN_MATCH", +} +var CSODOTAParty_State_value = map[string]int32{ + "UI": 0, + "FINDING_MATCH": 1, + "IN_MATCH": 2, +} + +func (x CSODOTAParty_State) Enum() *CSODOTAParty_State { + p := new(CSODOTAParty_State) + *p = x + return p +} +func (x CSODOTAParty_State) String() string { + return proto.EnumName(CSODOTAParty_State_name, int32(x)) +} +func (x *CSODOTAParty_State) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CSODOTAParty_State_value, data, "CSODOTAParty_State") + if err != nil { + return err + } + *x = CSODOTAParty_State(value) + return nil +} +func (CSODOTAParty_State) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{2, 0} } + +type CSODOTALobby_State int32 + +const ( + CSODOTALobby_UI CSODOTALobby_State = 0 + CSODOTALobby_READYUP CSODOTALobby_State = 4 + CSODOTALobby_SERVERSETUP CSODOTALobby_State = 1 + CSODOTALobby_RUN CSODOTALobby_State = 2 + CSODOTALobby_POSTGAME CSODOTALobby_State = 3 + CSODOTALobby_NOTREADY CSODOTALobby_State = 5 + CSODOTALobby_SERVERASSIGN CSODOTALobby_State = 6 +) + +var CSODOTALobby_State_name = map[int32]string{ + 0: "UI", + 4: "READYUP", + 1: "SERVERSETUP", + 2: "RUN", + 3: "POSTGAME", + 5: "NOTREADY", + 6: "SERVERASSIGN", +} +var CSODOTALobby_State_value = map[string]int32{ + "UI": 0, + "READYUP": 4, + "SERVERSETUP": 1, + "RUN": 2, + "POSTGAME": 3, + "NOTREADY": 5, + "SERVERASSIGN": 6, +} + +func (x CSODOTALobby_State) Enum() *CSODOTALobby_State { + p := new(CSODOTALobby_State) + *p = x + return p +} +func (x CSODOTALobby_State) String() string { + return proto.EnumName(CSODOTALobby_State_name, int32(x)) +} +func (x *CSODOTALobby_State) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CSODOTALobby_State_value, data, "CSODOTALobby_State") + if err != nil { + return err + } + *x = CSODOTALobby_State(value) + return nil +} +func (CSODOTALobby_State) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{12, 0} } + +type CSODOTALobby_LobbyType int32 + +const ( + CSODOTALobby_INVALID CSODOTALobby_LobbyType = -1 + CSODOTALobby_CASUAL_MATCH CSODOTALobby_LobbyType = 0 + CSODOTALobby_PRACTICE CSODOTALobby_LobbyType = 1 + CSODOTALobby_TOURNAMENT CSODOTALobby_LobbyType = 2 + CSODOTALobby_COOP_BOT_MATCH CSODOTALobby_LobbyType = 4 + CSODOTALobby_LEGACY_TEAM_MATCH CSODOTALobby_LobbyType = 5 + CSODOTALobby_LEGACY_SOLO_QUEUE_MATCH CSODOTALobby_LobbyType = 6 + CSODOTALobby_COMPETITIVE_MATCH CSODOTALobby_LobbyType = 7 + CSODOTALobby_CASUAL_1V1_MATCH CSODOTALobby_LobbyType = 8 + CSODOTALobby_WEEKEND_TOURNEY CSODOTALobby_LobbyType = 9 + CSODOTALobby_LOCAL_BOT_MATCH CSODOTALobby_LobbyType = 10 +) + +var CSODOTALobby_LobbyType_name = map[int32]string{ + -1: "INVALID", + 0: "CASUAL_MATCH", + 1: "PRACTICE", + 2: "TOURNAMENT", + 4: "COOP_BOT_MATCH", + 5: "LEGACY_TEAM_MATCH", + 6: "LEGACY_SOLO_QUEUE_MATCH", + 7: "COMPETITIVE_MATCH", + 8: "CASUAL_1V1_MATCH", + 9: "WEEKEND_TOURNEY", + 10: "LOCAL_BOT_MATCH", +} +var CSODOTALobby_LobbyType_value = map[string]int32{ + "INVALID": -1, + "CASUAL_MATCH": 0, + "PRACTICE": 1, + "TOURNAMENT": 2, + "COOP_BOT_MATCH": 4, + "LEGACY_TEAM_MATCH": 5, + "LEGACY_SOLO_QUEUE_MATCH": 6, + "COMPETITIVE_MATCH": 7, + "CASUAL_1V1_MATCH": 8, + "WEEKEND_TOURNEY": 9, + "LOCAL_BOT_MATCH": 10, +} + +func (x CSODOTALobby_LobbyType) Enum() *CSODOTALobby_LobbyType { + p := new(CSODOTALobby_LobbyType) + *p = x + return p +} +func (x CSODOTALobby_LobbyType) String() string { + return proto.EnumName(CSODOTALobby_LobbyType_name, int32(x)) +} +func (x *CSODOTALobby_LobbyType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CSODOTALobby_LobbyType_value, data, "CSODOTALobby_LobbyType") + if err != nil { + return err + } + *x = CSODOTALobby_LobbyType(value) + return nil +} +func (CSODOTALobby_LobbyType) EnumDescriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{12, 1} } + +type CMsgPerfectWorldUserLookupResponse_EResultCode int32 + +const ( + CMsgPerfectWorldUserLookupResponse_SUCCESS_ACCOUNT_FOUND CMsgPerfectWorldUserLookupResponse_EResultCode = 0 + CMsgPerfectWorldUserLookupResponse_ERROR_UNKNOWN CMsgPerfectWorldUserLookupResponse_EResultCode = 1 + CMsgPerfectWorldUserLookupResponse_ERROR_USER_NAME_WRONG_FORMAT CMsgPerfectWorldUserLookupResponse_EResultCode = 2 + CMsgPerfectWorldUserLookupResponse_ERROR_NO_PERFECT_WORLD_ACCOUNT_FOUND CMsgPerfectWorldUserLookupResponse_EResultCode = 3 + CMsgPerfectWorldUserLookupResponse_ERROR_NO_LINKED_STEAM_ACCOUNT_FOUND CMsgPerfectWorldUserLookupResponse_EResultCode = 4 +) + +var CMsgPerfectWorldUserLookupResponse_EResultCode_name = map[int32]string{ + 0: "SUCCESS_ACCOUNT_FOUND", + 1: "ERROR_UNKNOWN", + 2: "ERROR_USER_NAME_WRONG_FORMAT", + 3: "ERROR_NO_PERFECT_WORLD_ACCOUNT_FOUND", + 4: "ERROR_NO_LINKED_STEAM_ACCOUNT_FOUND", +} +var CMsgPerfectWorldUserLookupResponse_EResultCode_value = map[string]int32{ + "SUCCESS_ACCOUNT_FOUND": 0, + "ERROR_UNKNOWN": 1, + "ERROR_USER_NAME_WRONG_FORMAT": 2, + "ERROR_NO_PERFECT_WORLD_ACCOUNT_FOUND": 3, + "ERROR_NO_LINKED_STEAM_ACCOUNT_FOUND": 4, +} + +func (x CMsgPerfectWorldUserLookupResponse_EResultCode) Enum() *CMsgPerfectWorldUserLookupResponse_EResultCode { + p := new(CMsgPerfectWorldUserLookupResponse_EResultCode) + *p = x + return p +} +func (x CMsgPerfectWorldUserLookupResponse_EResultCode) String() string { + return proto.EnumName(CMsgPerfectWorldUserLookupResponse_EResultCode_name, int32(x)) +} +func (x *CMsgPerfectWorldUserLookupResponse_EResultCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgPerfectWorldUserLookupResponse_EResultCode_value, data, "CMsgPerfectWorldUserLookupResponse_EResultCode") + if err != nil { + return err + } + *x = CMsgPerfectWorldUserLookupResponse_EResultCode(value) + return nil +} +func (CMsgPerfectWorldUserLookupResponse_EResultCode) EnumDescriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{36, 0} +} + +type CMsgDOTARedeemItemResponse_EResultCode int32 + +const ( + CMsgDOTARedeemItemResponse_k_Succeeded CMsgDOTARedeemItemResponse_EResultCode = 0 + CMsgDOTARedeemItemResponse_k_Failed CMsgDOTARedeemItemResponse_EResultCode = 1 +) + +var CMsgDOTARedeemItemResponse_EResultCode_name = map[int32]string{ + 0: "k_Succeeded", + 1: "k_Failed", +} +var CMsgDOTARedeemItemResponse_EResultCode_value = map[string]int32{ + "k_Succeeded": 0, + "k_Failed": 1, +} + +func (x CMsgDOTARedeemItemResponse_EResultCode) Enum() *CMsgDOTARedeemItemResponse_EResultCode { + p := new(CMsgDOTARedeemItemResponse_EResultCode) + *p = x + return p +} +func (x CMsgDOTARedeemItemResponse_EResultCode) String() string { + return proto.EnumName(CMsgDOTARedeemItemResponse_EResultCode_name, int32(x)) +} +func (x *CMsgDOTARedeemItemResponse_EResultCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTARedeemItemResponse_EResultCode_value, data, "CMsgDOTARedeemItemResponse_EResultCode") + if err != nil { + return err + } + *x = CMsgDOTARedeemItemResponse_EResultCode(value) + return nil +} +func (CMsgDOTARedeemItemResponse_EResultCode) EnumDescriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{42, 0} +} + +type CMsgDOTAProfileCard_EStatID int32 + +const ( + CMsgDOTAProfileCard_k_eStat_SoloRank CMsgDOTAProfileCard_EStatID = 1 + CMsgDOTAProfileCard_k_eStat_PartyRank CMsgDOTAProfileCard_EStatID = 2 + CMsgDOTAProfileCard_k_eStat_Wins CMsgDOTAProfileCard_EStatID = 3 + CMsgDOTAProfileCard_k_eStat_Commends CMsgDOTAProfileCard_EStatID = 4 + CMsgDOTAProfileCard_k_eStat_GamesPlayed CMsgDOTAProfileCard_EStatID = 5 + CMsgDOTAProfileCard_k_eStat_FirstMatchDate CMsgDOTAProfileCard_EStatID = 6 +) + +var CMsgDOTAProfileCard_EStatID_name = map[int32]string{ + 1: "k_eStat_SoloRank", + 2: "k_eStat_PartyRank", + 3: "k_eStat_Wins", + 4: "k_eStat_Commends", + 5: "k_eStat_GamesPlayed", + 6: "k_eStat_FirstMatchDate", +} +var CMsgDOTAProfileCard_EStatID_value = map[string]int32{ + "k_eStat_SoloRank": 1, + "k_eStat_PartyRank": 2, + "k_eStat_Wins": 3, + "k_eStat_Commends": 4, + "k_eStat_GamesPlayed": 5, + "k_eStat_FirstMatchDate": 6, +} + +func (x CMsgDOTAProfileCard_EStatID) Enum() *CMsgDOTAProfileCard_EStatID { + p := new(CMsgDOTAProfileCard_EStatID) + *p = x + return p +} +func (x CMsgDOTAProfileCard_EStatID) String() string { + return proto.EnumName(CMsgDOTAProfileCard_EStatID_name, int32(x)) +} +func (x *CMsgDOTAProfileCard_EStatID) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTAProfileCard_EStatID_value, data, "CMsgDOTAProfileCard_EStatID") + if err != nil { + return err + } + *x = CMsgDOTAProfileCard_EStatID(value) + return nil +} +func (CMsgDOTAProfileCard_EStatID) EnumDescriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{44, 0} +} + +type CSODOTAPlayerChallenge_EFlags int32 + +const ( + CSODOTAPlayerChallenge_eFlag_InstantRerollUncompleted CSODOTAPlayerChallenge_EFlags = 1 + CSODOTAPlayerChallenge_eFlag_QuestChallenge CSODOTAPlayerChallenge_EFlags = 2 +) + +var CSODOTAPlayerChallenge_EFlags_name = map[int32]string{ + 1: "eFlag_InstantRerollUncompleted", + 2: "eFlag_QuestChallenge", +} +var CSODOTAPlayerChallenge_EFlags_value = map[string]int32{ + "eFlag_InstantRerollUncompleted": 1, + "eFlag_QuestChallenge": 2, +} + +func (x CSODOTAPlayerChallenge_EFlags) Enum() *CSODOTAPlayerChallenge_EFlags { + p := new(CSODOTAPlayerChallenge_EFlags) + *p = x + return p +} +func (x CSODOTAPlayerChallenge_EFlags) String() string { + return proto.EnumName(CSODOTAPlayerChallenge_EFlags_name, int32(x)) +} +func (x *CSODOTAPlayerChallenge_EFlags) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CSODOTAPlayerChallenge_EFlags_value, data, "CSODOTAPlayerChallenge_EFlags") + if err != nil { + return err + } + *x = CSODOTAPlayerChallenge_EFlags(value) + return nil +} +func (CSODOTAPlayerChallenge_EFlags) EnumDescriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{46, 0} +} + +type CMsgGCRerollPlayerChallengeResponse_EResult int32 + +const ( + CMsgGCRerollPlayerChallengeResponse_eResult_Success CMsgGCRerollPlayerChallengeResponse_EResult = 0 + CMsgGCRerollPlayerChallengeResponse_eResult_Dropped CMsgGCRerollPlayerChallengeResponse_EResult = 1 + CMsgGCRerollPlayerChallengeResponse_eResult_NotFound CMsgGCRerollPlayerChallengeResponse_EResult = 2 + CMsgGCRerollPlayerChallengeResponse_eResult_CantReroll CMsgGCRerollPlayerChallengeResponse_EResult = 3 + CMsgGCRerollPlayerChallengeResponse_eResult_ServerError CMsgGCRerollPlayerChallengeResponse_EResult = 4 +) + +var CMsgGCRerollPlayerChallengeResponse_EResult_name = map[int32]string{ + 0: "eResult_Success", + 1: "eResult_Dropped", + 2: "eResult_NotFound", + 3: "eResult_CantReroll", + 4: "eResult_ServerError", +} +var CMsgGCRerollPlayerChallengeResponse_EResult_value = map[string]int32{ + "eResult_Success": 0, + "eResult_Dropped": 1, + "eResult_NotFound": 2, + "eResult_CantReroll": 3, + "eResult_ServerError": 4, +} + +func (x CMsgGCRerollPlayerChallengeResponse_EResult) Enum() *CMsgGCRerollPlayerChallengeResponse_EResult { + p := new(CMsgGCRerollPlayerChallengeResponse_EResult) + *p = x + return p +} +func (x CMsgGCRerollPlayerChallengeResponse_EResult) String() string { + return proto.EnumName(CMsgGCRerollPlayerChallengeResponse_EResult_name, int32(x)) +} +func (x *CMsgGCRerollPlayerChallengeResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgGCRerollPlayerChallengeResponse_EResult_value, data, "CMsgGCRerollPlayerChallengeResponse_EResult") + if err != nil { + return err + } + *x = CMsgGCRerollPlayerChallengeResponse_EResult(value) + return nil +} +func (CMsgGCRerollPlayerChallengeResponse_EResult) EnumDescriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{48, 0} +} + +type CMsgDOTARealtimeGameStats_GraphDataEStat int32 + +const ( + CMsgDOTARealtimeGameStats_GraphData_CreepGoldEarned CMsgDOTARealtimeGameStats_GraphDataEStat = 0 + CMsgDOTARealtimeGameStats_GraphData_KillGoldEarned CMsgDOTARealtimeGameStats_GraphDataEStat = 1 + CMsgDOTARealtimeGameStats_GraphData_DeathAndBuybackGoldLost CMsgDOTARealtimeGameStats_GraphDataEStat = 2 + CMsgDOTARealtimeGameStats_GraphData_XPEarned CMsgDOTARealtimeGameStats_GraphDataEStat = 3 +) + +var CMsgDOTARealtimeGameStats_GraphDataEStat_name = map[int32]string{ + 0: "CreepGoldEarned", + 1: "KillGoldEarned", + 2: "DeathAndBuybackGoldLost", + 3: "XPEarned", +} +var CMsgDOTARealtimeGameStats_GraphDataEStat_value = map[string]int32{ + "CreepGoldEarned": 0, + "KillGoldEarned": 1, + "DeathAndBuybackGoldLost": 2, + "XPEarned": 3, +} + +func (x CMsgDOTARealtimeGameStats_GraphDataEStat) Enum() *CMsgDOTARealtimeGameStats_GraphDataEStat { + p := new(CMsgDOTARealtimeGameStats_GraphDataEStat) + *p = x + return p +} +func (x CMsgDOTARealtimeGameStats_GraphDataEStat) String() string { + return proto.EnumName(CMsgDOTARealtimeGameStats_GraphDataEStat_name, int32(x)) +} +func (x *CMsgDOTARealtimeGameStats_GraphDataEStat) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTARealtimeGameStats_GraphDataEStat_value, data, "CMsgDOTARealtimeGameStats_GraphDataEStat") + if err != nil { + return err + } + *x = CMsgDOTARealtimeGameStats_GraphDataEStat(value) + return nil +} +func (CMsgDOTARealtimeGameStats_GraphDataEStat) EnumDescriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 11, 0} +} + +type CMsgDOTARealtimeGameStats_GraphDataELocation int32 + +const ( + CMsgDOTARealtimeGameStats_GraphData_BotLane CMsgDOTARealtimeGameStats_GraphDataELocation = 0 + CMsgDOTARealtimeGameStats_GraphData_MidLane CMsgDOTARealtimeGameStats_GraphDataELocation = 1 + CMsgDOTARealtimeGameStats_GraphData_TopLane CMsgDOTARealtimeGameStats_GraphDataELocation = 2 + CMsgDOTARealtimeGameStats_GraphData_Jungle CMsgDOTARealtimeGameStats_GraphDataELocation = 3 + CMsgDOTARealtimeGameStats_GraphData_Ancients CMsgDOTARealtimeGameStats_GraphDataELocation = 4 + CMsgDOTARealtimeGameStats_GraphData_Other CMsgDOTARealtimeGameStats_GraphDataELocation = 5 +) + +var CMsgDOTARealtimeGameStats_GraphDataELocation_name = map[int32]string{ + 0: "BotLane", + 1: "MidLane", + 2: "TopLane", + 3: "Jungle", + 4: "Ancients", + 5: "Other", +} +var CMsgDOTARealtimeGameStats_GraphDataELocation_value = map[string]int32{ + "BotLane": 0, + "MidLane": 1, + "TopLane": 2, + "Jungle": 3, + "Ancients": 4, + "Other": 5, +} + +func (x CMsgDOTARealtimeGameStats_GraphDataELocation) Enum() *CMsgDOTARealtimeGameStats_GraphDataELocation { + p := new(CMsgDOTARealtimeGameStats_GraphDataELocation) + *p = x + return p +} +func (x CMsgDOTARealtimeGameStats_GraphDataELocation) String() string { + return proto.EnumName(CMsgDOTARealtimeGameStats_GraphDataELocation_name, int32(x)) +} +func (x *CMsgDOTARealtimeGameStats_GraphDataELocation) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgDOTARealtimeGameStats_GraphDataELocation_value, data, "CMsgDOTARealtimeGameStats_GraphDataELocation") + if err != nil { + return err + } + *x = CMsgDOTARealtimeGameStats_GraphDataELocation(value) + return nil +} +func (CMsgDOTARealtimeGameStats_GraphDataELocation) EnumDescriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 11, 1} +} + +type CSODOTAGameAccountClient struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Wins *uint32 `protobuf:"varint,3,opt,name=wins" json:"wins,omitempty"` + Losses *uint32 `protobuf:"varint,4,opt,name=losses" json:"losses,omitempty"` + Xp *uint32 `protobuf:"varint,12,opt,name=xp" json:"xp,omitempty"` + Level *uint32 `protobuf:"varint,13,opt,name=level" json:"level,omitempty"` + InitialSkill *uint32 `protobuf:"varint,14,opt,name=initial_skill" json:"initial_skill,omitempty"` + LeaverCount *uint32 `protobuf:"varint,15,opt,name=leaver_count" json:"leaver_count,omitempty"` + SecondaryLeaverCount *uint32 `protobuf:"varint,58,opt,name=secondary_leaver_count" json:"secondary_leaver_count,omitempty"` + LowPriorityUntilDate *uint32 `protobuf:"varint,18,opt,name=low_priority_until_date" json:"low_priority_until_date,omitempty"` + PreventTextChatUntilDate *uint32 `protobuf:"varint,20,opt,name=prevent_text_chat_until_date" json:"prevent_text_chat_until_date,omitempty"` + PreventVoiceUntilDate *uint32 `protobuf:"varint,21,opt,name=prevent_voice_until_date" json:"prevent_voice_until_date,omitempty"` + LastAbandonedGameDate *uint32 `protobuf:"varint,22,opt,name=last_abandoned_game_date" json:"last_abandoned_game_date,omitempty"` + LastSecondaryAbandonedGameDate *uint32 `protobuf:"varint,59,opt,name=last_secondary_abandoned_game_date" json:"last_secondary_abandoned_game_date,omitempty"` + LeaverPenaltyCount *uint32 `protobuf:"varint,23,opt,name=leaver_penalty_count" json:"leaver_penalty_count,omitempty"` + CompletedGameStreak *uint32 `protobuf:"varint,24,opt,name=completed_game_streak" json:"completed_game_streak,omitempty"` + Teaching *uint32 `protobuf:"varint,28,opt,name=teaching" json:"teaching,omitempty"` + Leadership *uint32 `protobuf:"varint,29,opt,name=leadership" json:"leadership,omitempty"` + Friendly *uint32 `protobuf:"varint,30,opt,name=friendly" json:"friendly,omitempty"` + Forgiving *uint32 `protobuf:"varint,31,opt,name=forgiving" json:"forgiving,omitempty"` + AccountDisabledUntilDate *uint32 `protobuf:"varint,38,opt,name=account_disabled_until_date" json:"account_disabled_until_date,omitempty"` + AccountDisabledCount *uint32 `protobuf:"varint,39,opt,name=account_disabled_count" json:"account_disabled_count,omitempty"` + ShowcaseHeroId *uint32 `protobuf:"varint,40,opt,name=showcase_hero_id" json:"showcase_hero_id,omitempty"` + MatchDisabledUntilDate *uint32 `protobuf:"varint,41,opt,name=match_disabled_until_date" json:"match_disabled_until_date,omitempty"` + MatchDisabledCount *uint32 `protobuf:"varint,42,opt,name=match_disabled_count" json:"match_disabled_count,omitempty"` + PartnerAccountType *PartnerAccountType `protobuf:"varint,44,opt,name=partner_account_type,enum=PartnerAccountType,def=0" json:"partner_account_type,omitempty"` + PartnerAccountState *uint32 `protobuf:"varint,45,opt,name=partner_account_state" json:"partner_account_state,omitempty"` + Shutdownlawterminatetimestamp *uint32 `protobuf:"varint,47,opt,name=shutdownlawterminatetimestamp" json:"shutdownlawterminatetimestamp,omitempty"` + LowPriorityGamesRemaining *uint32 `protobuf:"varint,48,opt,name=low_priority_games_remaining" json:"low_priority_games_remaining,omitempty"` + CompetitiveRank *uint32 `protobuf:"varint,49,opt,name=competitive_rank" json:"competitive_rank,omitempty"` + CalibrationGamesRemaining *uint32 `protobuf:"varint,51,opt,name=calibration_games_remaining" json:"calibration_games_remaining,omitempty"` + SoloCompetitiveRank *uint32 `protobuf:"varint,52,opt,name=solo_competitive_rank" json:"solo_competitive_rank,omitempty"` + SoloCalibrationGamesRemaining *uint32 `protobuf:"varint,54,opt,name=solo_calibration_games_remaining" json:"solo_calibration_games_remaining,omitempty"` + Competitive_1V1Rank *uint32 `protobuf:"varint,63,opt,name=competitive_1v1_rank" json:"competitive_1v1_rank,omitempty"` + Competitive_1V1CalibrationGamesRemaining *uint32 `protobuf:"varint,64,opt,name=competitive_1v1_calibration_games_remaining" json:"competitive_1v1_calibration_games_remaining,omitempty"` + RecruitmentLevel *uint32 `protobuf:"varint,55,opt,name=recruitment_level" json:"recruitment_level,omitempty"` + HasNewNotifications *bool `protobuf:"varint,56,opt,name=has_new_notifications" json:"has_new_notifications,omitempty"` + IsLeagueAdmin *bool `protobuf:"varint,57,opt,name=is_league_admin" json:"is_league_admin,omitempty"` + CasualGamesPlayed *uint32 `protobuf:"varint,60,opt,name=casual_games_played" json:"casual_games_played,omitempty"` + SoloCompetitiveGamesPlayed *uint32 `protobuf:"varint,61,opt,name=solo_competitive_games_played" json:"solo_competitive_games_played,omitempty"` + PartyCompetitiveGamesPlayed *uint32 `protobuf:"varint,62,opt,name=party_competitive_games_played" json:"party_competitive_games_played,omitempty"` + Casual_1V1GamesPlayed *uint32 `protobuf:"varint,65,opt,name=casual_1v1_games_played" json:"casual_1v1_games_played,omitempty"` + CompetitiveTeamGamesPlayed *uint32 `protobuf:"varint,66,opt,name=competitive_team_games_played" json:"competitive_team_games_played,omitempty"` + CurrAllHeroChallengeId *uint32 `protobuf:"varint,67,opt,name=curr_all_hero_challenge_id" json:"curr_all_hero_challenge_id,omitempty"` + PlayTimePoints *uint32 `protobuf:"varint,68,opt,name=play_time_points" json:"play_time_points,omitempty"` + AccountFlags *uint32 `protobuf:"varint,69,opt,name=account_flags" json:"account_flags,omitempty"` + PlayTimeLevel *uint32 `protobuf:"varint,70,opt,name=play_time_level" json:"play_time_level,omitempty"` + PlayerBehaviorSeqNumLastReport *uint32 `protobuf:"varint,71,opt,name=player_behavior_seq_num_last_report" json:"player_behavior_seq_num_last_report,omitempty"` + PlayerBehaviorScoreLastReport *uint32 `protobuf:"varint,72,opt,name=player_behavior_score_last_report" json:"player_behavior_score_last_report,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAGameAccountClient) Reset() { *m = CSODOTAGameAccountClient{} } +func (m *CSODOTAGameAccountClient) String() string { return proto.CompactTextString(m) } +func (*CSODOTAGameAccountClient) ProtoMessage() {} +func (*CSODOTAGameAccountClient) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{0} } + +const Default_CSODOTAGameAccountClient_PartnerAccountType PartnerAccountType = PartnerAccountType_PARTNER_NONE + +func (m *CSODOTAGameAccountClient) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetWins() uint32 { + if m != nil && m.Wins != nil { + return *m.Wins + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLosses() uint32 { + if m != nil && m.Losses != nil { + return *m.Losses + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetXp() uint32 { + if m != nil && m.Xp != nil { + return *m.Xp + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLevel() uint32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetInitialSkill() uint32 { + if m != nil && m.InitialSkill != nil { + return *m.InitialSkill + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLeaverCount() uint32 { + if m != nil && m.LeaverCount != nil { + return *m.LeaverCount + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetSecondaryLeaverCount() uint32 { + if m != nil && m.SecondaryLeaverCount != nil { + return *m.SecondaryLeaverCount + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLowPriorityUntilDate() uint32 { + if m != nil && m.LowPriorityUntilDate != nil { + return *m.LowPriorityUntilDate + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPreventTextChatUntilDate() uint32 { + if m != nil && m.PreventTextChatUntilDate != nil { + return *m.PreventTextChatUntilDate + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPreventVoiceUntilDate() uint32 { + if m != nil && m.PreventVoiceUntilDate != nil { + return *m.PreventVoiceUntilDate + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLastAbandonedGameDate() uint32 { + if m != nil && m.LastAbandonedGameDate != nil { + return *m.LastAbandonedGameDate + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLastSecondaryAbandonedGameDate() uint32 { + if m != nil && m.LastSecondaryAbandonedGameDate != nil { + return *m.LastSecondaryAbandonedGameDate + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLeaverPenaltyCount() uint32 { + if m != nil && m.LeaverPenaltyCount != nil { + return *m.LeaverPenaltyCount + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCompletedGameStreak() uint32 { + if m != nil && m.CompletedGameStreak != nil { + return *m.CompletedGameStreak + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetTeaching() uint32 { + if m != nil && m.Teaching != nil { + return *m.Teaching + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLeadership() uint32 { + if m != nil && m.Leadership != nil { + return *m.Leadership + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetFriendly() uint32 { + if m != nil && m.Friendly != nil { + return *m.Friendly + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetForgiving() uint32 { + if m != nil && m.Forgiving != nil { + return *m.Forgiving + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetAccountDisabledUntilDate() uint32 { + if m != nil && m.AccountDisabledUntilDate != nil { + return *m.AccountDisabledUntilDate + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetAccountDisabledCount() uint32 { + if m != nil && m.AccountDisabledCount != nil { + return *m.AccountDisabledCount + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetShowcaseHeroId() uint32 { + if m != nil && m.ShowcaseHeroId != nil { + return *m.ShowcaseHeroId + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetMatchDisabledUntilDate() uint32 { + if m != nil && m.MatchDisabledUntilDate != nil { + return *m.MatchDisabledUntilDate + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetMatchDisabledCount() uint32 { + if m != nil && m.MatchDisabledCount != nil { + return *m.MatchDisabledCount + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPartnerAccountType() PartnerAccountType { + if m != nil && m.PartnerAccountType != nil { + return *m.PartnerAccountType + } + return Default_CSODOTAGameAccountClient_PartnerAccountType +} + +func (m *CSODOTAGameAccountClient) GetPartnerAccountState() uint32 { + if m != nil && m.PartnerAccountState != nil { + return *m.PartnerAccountState + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetShutdownlawterminatetimestamp() uint32 { + if m != nil && m.Shutdownlawterminatetimestamp != nil { + return *m.Shutdownlawterminatetimestamp + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetLowPriorityGamesRemaining() uint32 { + if m != nil && m.LowPriorityGamesRemaining != nil { + return *m.LowPriorityGamesRemaining + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCompetitiveRank() uint32 { + if m != nil && m.CompetitiveRank != nil { + return *m.CompetitiveRank + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCalibrationGamesRemaining() uint32 { + if m != nil && m.CalibrationGamesRemaining != nil { + return *m.CalibrationGamesRemaining + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetSoloCompetitiveRank() uint32 { + if m != nil && m.SoloCompetitiveRank != nil { + return *m.SoloCompetitiveRank + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetSoloCalibrationGamesRemaining() uint32 { + if m != nil && m.SoloCalibrationGamesRemaining != nil { + return *m.SoloCalibrationGamesRemaining + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCompetitive_1V1Rank() uint32 { + if m != nil && m.Competitive_1V1Rank != nil { + return *m.Competitive_1V1Rank + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCompetitive_1V1CalibrationGamesRemaining() uint32 { + if m != nil && m.Competitive_1V1CalibrationGamesRemaining != nil { + return *m.Competitive_1V1CalibrationGamesRemaining + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetRecruitmentLevel() uint32 { + if m != nil && m.RecruitmentLevel != nil { + return *m.RecruitmentLevel + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetHasNewNotifications() bool { + if m != nil && m.HasNewNotifications != nil { + return *m.HasNewNotifications + } + return false +} + +func (m *CSODOTAGameAccountClient) GetIsLeagueAdmin() bool { + if m != nil && m.IsLeagueAdmin != nil { + return *m.IsLeagueAdmin + } + return false +} + +func (m *CSODOTAGameAccountClient) GetCasualGamesPlayed() uint32 { + if m != nil && m.CasualGamesPlayed != nil { + return *m.CasualGamesPlayed + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetSoloCompetitiveGamesPlayed() uint32 { + if m != nil && m.SoloCompetitiveGamesPlayed != nil { + return *m.SoloCompetitiveGamesPlayed + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPartyCompetitiveGamesPlayed() uint32 { + if m != nil && m.PartyCompetitiveGamesPlayed != nil { + return *m.PartyCompetitiveGamesPlayed + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCasual_1V1GamesPlayed() uint32 { + if m != nil && m.Casual_1V1GamesPlayed != nil { + return *m.Casual_1V1GamesPlayed + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCompetitiveTeamGamesPlayed() uint32 { + if m != nil && m.CompetitiveTeamGamesPlayed != nil { + return *m.CompetitiveTeamGamesPlayed + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetCurrAllHeroChallengeId() uint32 { + if m != nil && m.CurrAllHeroChallengeId != nil { + return *m.CurrAllHeroChallengeId + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPlayTimePoints() uint32 { + if m != nil && m.PlayTimePoints != nil { + return *m.PlayTimePoints + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetAccountFlags() uint32 { + if m != nil && m.AccountFlags != nil { + return *m.AccountFlags + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPlayTimeLevel() uint32 { + if m != nil && m.PlayTimeLevel != nil { + return *m.PlayTimeLevel + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPlayerBehaviorSeqNumLastReport() uint32 { + if m != nil && m.PlayerBehaviorSeqNumLastReport != nil { + return *m.PlayerBehaviorSeqNumLastReport + } + return 0 +} + +func (m *CSODOTAGameAccountClient) GetPlayerBehaviorScoreLastReport() uint32 { + if m != nil && m.PlayerBehaviorScoreLastReport != nil { + return *m.PlayerBehaviorScoreLastReport + } + return 0 +} + +type CSODOTAPartyMember struct { + PartnerType *PartnerAccountType `protobuf:"varint,1,opt,name=partner_type,enum=PartnerAccountType,def=0" json:"partner_type,omitempty"` + IsCoach *bool `protobuf:"varint,2,opt,name=is_coach" json:"is_coach,omitempty"` + RegionPingCodes []uint32 `protobuf:"varint,4,rep,packed,name=region_ping_codes" json:"region_ping_codes,omitempty"` + RegionPingTimes []uint32 `protobuf:"varint,5,rep,packed,name=region_ping_times" json:"region_ping_times,omitempty"` + RegionPingFailedBitmask *uint32 `protobuf:"varint,6,opt,name=region_ping_failed_bitmask" json:"region_ping_failed_bitmask,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAPartyMember) Reset() { *m = CSODOTAPartyMember{} } +func (m *CSODOTAPartyMember) String() string { return proto.CompactTextString(m) } +func (*CSODOTAPartyMember) ProtoMessage() {} +func (*CSODOTAPartyMember) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{1} } + +const Default_CSODOTAPartyMember_PartnerType PartnerAccountType = PartnerAccountType_PARTNER_NONE + +func (m *CSODOTAPartyMember) GetPartnerType() PartnerAccountType { + if m != nil && m.PartnerType != nil { + return *m.PartnerType + } + return Default_CSODOTAPartyMember_PartnerType +} + +func (m *CSODOTAPartyMember) GetIsCoach() bool { + if m != nil && m.IsCoach != nil { + return *m.IsCoach + } + return false +} + +func (m *CSODOTAPartyMember) GetRegionPingCodes() []uint32 { + if m != nil { + return m.RegionPingCodes + } + return nil +} + +func (m *CSODOTAPartyMember) GetRegionPingTimes() []uint32 { + if m != nil { + return m.RegionPingTimes + } + return nil +} + +func (m *CSODOTAPartyMember) GetRegionPingFailedBitmask() uint32 { + if m != nil && m.RegionPingFailedBitmask != nil { + return *m.RegionPingFailedBitmask + } + return 0 +} + +type CSODOTAParty struct { + PartyId *uint64 `protobuf:"varint,1,opt,name=party_id" json:"party_id,omitempty"` + LeaderId *uint64 `protobuf:"fixed64,2,opt,name=leader_id" json:"leader_id,omitempty"` + MemberIds []uint64 `protobuf:"fixed64,3,rep,name=member_ids" json:"member_ids,omitempty"` + GameModes *uint32 `protobuf:"varint,4,opt,name=game_modes" json:"game_modes,omitempty"` + State *CSODOTAParty_State `protobuf:"varint,6,opt,name=state,enum=CSODOTAParty_State,def=0" json:"state,omitempty"` + EffectiveStartedMatchmakingTime *uint32 `protobuf:"varint,7,opt,name=effective_started_matchmaking_time" json:"effective_started_matchmaking_time,omitempty"` + RawStartedMatchmakingTime *uint32 `protobuf:"varint,32,opt,name=raw_started_matchmaking_time" json:"raw_started_matchmaking_time,omitempty"` + AttemptStartTime *uint32 `protobuf:"varint,33,opt,name=attempt_start_time" json:"attempt_start_time,omitempty"` + AttemptNum *uint32 `protobuf:"varint,34,opt,name=attempt_num" json:"attempt_num,omitempty"` + Matchgroups *uint32 `protobuf:"varint,11,opt,name=matchgroups" json:"matchgroups,omitempty"` + LowPriorityAccountId *uint32 `protobuf:"varint,19,opt,name=low_priority_account_id" json:"low_priority_account_id,omitempty"` + MatchType *MatchType `protobuf:"varint,21,opt,name=match_type,enum=MatchType,def=0" json:"match_type,omitempty"` + BotDifficulty *DOTABotDifficulty `protobuf:"varint,22,opt,name=bot_difficulty,enum=DOTABotDifficulty,def=0" json:"bot_difficulty,omitempty"` + TeamId *uint32 `protobuf:"varint,23,opt,name=team_id" json:"team_id,omitempty"` + MatchDisabledUntilDate *uint32 `protobuf:"varint,24,opt,name=match_disabled_until_date" json:"match_disabled_until_date,omitempty"` + MatchDisabledAccountId *uint32 `protobuf:"varint,25,opt,name=match_disabled_account_id" json:"match_disabled_account_id,omitempty"` + MatchmakingMaxRangeMinutes *uint32 `protobuf:"varint,26,opt,name=matchmaking_max_range_minutes" json:"matchmaking_max_range_minutes,omitempty"` + Matchlanguages *uint32 `protobuf:"varint,27,opt,name=matchlanguages" json:"matchlanguages,omitempty"` + MapPreference *uint32 `protobuf:"varint,38,opt,name=map_preference" json:"map_preference,omitempty"` + Members []*CSODOTAPartyMember `protobuf:"bytes,29,rep,name=members" json:"members,omitempty"` + OpenGuildId *uint32 `protobuf:"varint,30,opt,name=open_guild_id" json:"open_guild_id,omitempty"` + CommonGuilds []uint32 `protobuf:"varint,31,rep,name=common_guilds" json:"common_guilds,omitempty"` + LowPriorityGamesRemaining *uint32 `protobuf:"varint,35,opt,name=low_priority_games_remaining" json:"low_priority_games_remaining,omitempty"` + MinLevel *uint32 `protobuf:"varint,36,opt,name=min_level" json:"min_level,omitempty"` + MaxLevel *uint32 `protobuf:"varint,37,opt,name=max_level" json:"max_level,omitempty"` + ActiveIngameEvents []EEvent `protobuf:"varint,39,rep,name=active_ingame_events,enum=EEvent" json:"active_ingame_events,omitempty"` + OpenForJoinRequests *bool `protobuf:"varint,40,opt,name=open_for_join_requests" json:"open_for_join_requests,omitempty"` + SentInvites []*CSODOTAPartyInvite `protobuf:"bytes,41,rep,name=sent_invites" json:"sent_invites,omitempty"` + RecvInvites []*CSODOTAPartyInvite `protobuf:"bytes,42,rep,name=recv_invites" json:"recv_invites,omitempty"` + AccountFlags *uint32 `protobuf:"varint,43,opt,name=account_flags" json:"account_flags,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAParty) Reset() { *m = CSODOTAParty{} } +func (m *CSODOTAParty) String() string { return proto.CompactTextString(m) } +func (*CSODOTAParty) ProtoMessage() {} +func (*CSODOTAParty) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{2} } + +const Default_CSODOTAParty_State CSODOTAParty_State = CSODOTAParty_UI +const Default_CSODOTAParty_MatchType MatchType = MatchType_MATCH_TYPE_CASUAL +const Default_CSODOTAParty_BotDifficulty DOTABotDifficulty = DOTABotDifficulty_BOT_DIFFICULTY_PASSIVE + +func (m *CSODOTAParty) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CSODOTAParty) GetLeaderId() uint64 { + if m != nil && m.LeaderId != nil { + return *m.LeaderId + } + return 0 +} + +func (m *CSODOTAParty) GetMemberIds() []uint64 { + if m != nil { + return m.MemberIds + } + return nil +} + +func (m *CSODOTAParty) GetGameModes() uint32 { + if m != nil && m.GameModes != nil { + return *m.GameModes + } + return 0 +} + +func (m *CSODOTAParty) GetState() CSODOTAParty_State { + if m != nil && m.State != nil { + return *m.State + } + return Default_CSODOTAParty_State +} + +func (m *CSODOTAParty) GetEffectiveStartedMatchmakingTime() uint32 { + if m != nil && m.EffectiveStartedMatchmakingTime != nil { + return *m.EffectiveStartedMatchmakingTime + } + return 0 +} + +func (m *CSODOTAParty) GetRawStartedMatchmakingTime() uint32 { + if m != nil && m.RawStartedMatchmakingTime != nil { + return *m.RawStartedMatchmakingTime + } + return 0 +} + +func (m *CSODOTAParty) GetAttemptStartTime() uint32 { + if m != nil && m.AttemptStartTime != nil { + return *m.AttemptStartTime + } + return 0 +} + +func (m *CSODOTAParty) GetAttemptNum() uint32 { + if m != nil && m.AttemptNum != nil { + return *m.AttemptNum + } + return 0 +} + +func (m *CSODOTAParty) GetMatchgroups() uint32 { + if m != nil && m.Matchgroups != nil { + return *m.Matchgroups + } + return 0 +} + +func (m *CSODOTAParty) GetLowPriorityAccountId() uint32 { + if m != nil && m.LowPriorityAccountId != nil { + return *m.LowPriorityAccountId + } + return 0 +} + +func (m *CSODOTAParty) GetMatchType() MatchType { + if m != nil && m.MatchType != nil { + return *m.MatchType + } + return Default_CSODOTAParty_MatchType +} + +func (m *CSODOTAParty) GetBotDifficulty() DOTABotDifficulty { + if m != nil && m.BotDifficulty != nil { + return *m.BotDifficulty + } + return Default_CSODOTAParty_BotDifficulty +} + +func (m *CSODOTAParty) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CSODOTAParty) GetMatchDisabledUntilDate() uint32 { + if m != nil && m.MatchDisabledUntilDate != nil { + return *m.MatchDisabledUntilDate + } + return 0 +} + +func (m *CSODOTAParty) GetMatchDisabledAccountId() uint32 { + if m != nil && m.MatchDisabledAccountId != nil { + return *m.MatchDisabledAccountId + } + return 0 +} + +func (m *CSODOTAParty) GetMatchmakingMaxRangeMinutes() uint32 { + if m != nil && m.MatchmakingMaxRangeMinutes != nil { + return *m.MatchmakingMaxRangeMinutes + } + return 0 +} + +func (m *CSODOTAParty) GetMatchlanguages() uint32 { + if m != nil && m.Matchlanguages != nil { + return *m.Matchlanguages + } + return 0 +} + +func (m *CSODOTAParty) GetMapPreference() uint32 { + if m != nil && m.MapPreference != nil { + return *m.MapPreference + } + return 0 +} + +func (m *CSODOTAParty) GetMembers() []*CSODOTAPartyMember { + if m != nil { + return m.Members + } + return nil +} + +func (m *CSODOTAParty) GetOpenGuildId() uint32 { + if m != nil && m.OpenGuildId != nil { + return *m.OpenGuildId + } + return 0 +} + +func (m *CSODOTAParty) GetCommonGuilds() []uint32 { + if m != nil { + return m.CommonGuilds + } + return nil +} + +func (m *CSODOTAParty) GetLowPriorityGamesRemaining() uint32 { + if m != nil && m.LowPriorityGamesRemaining != nil { + return *m.LowPriorityGamesRemaining + } + return 0 +} + +func (m *CSODOTAParty) GetMinLevel() uint32 { + if m != nil && m.MinLevel != nil { + return *m.MinLevel + } + return 0 +} + +func (m *CSODOTAParty) GetMaxLevel() uint32 { + if m != nil && m.MaxLevel != nil { + return *m.MaxLevel + } + return 0 +} + +func (m *CSODOTAParty) GetActiveIngameEvents() []EEvent { + if m != nil { + return m.ActiveIngameEvents + } + return nil +} + +func (m *CSODOTAParty) GetOpenForJoinRequests() bool { + if m != nil && m.OpenForJoinRequests != nil { + return *m.OpenForJoinRequests + } + return false +} + +func (m *CSODOTAParty) GetSentInvites() []*CSODOTAPartyInvite { + if m != nil { + return m.SentInvites + } + return nil +} + +func (m *CSODOTAParty) GetRecvInvites() []*CSODOTAPartyInvite { + if m != nil { + return m.RecvInvites + } + return nil +} + +func (m *CSODOTAParty) GetAccountFlags() uint32 { + if m != nil && m.AccountFlags != nil { + return *m.AccountFlags + } + return 0 +} + +type CSODOTAPartyInvite struct { + GroupId *uint64 `protobuf:"varint,1,opt,name=group_id" json:"group_id,omitempty"` + SenderId *uint64 `protobuf:"fixed64,2,opt,name=sender_id" json:"sender_id,omitempty"` + SenderName *string `protobuf:"bytes,3,opt,name=sender_name" json:"sender_name,omitempty"` + Members []*CSODOTAPartyInvite_PartyMember `protobuf:"bytes,4,rep,name=members" json:"members,omitempty"` + TeamId *uint32 `protobuf:"varint,5,opt,name=team_id" json:"team_id,omitempty"` + LowPriorityStatus *bool `protobuf:"varint,6,opt,name=low_priority_status" json:"low_priority_status,omitempty"` + AsCoach *bool `protobuf:"varint,7,opt,name=as_coach" json:"as_coach,omitempty"` + InviteGid *uint64 `protobuf:"fixed64,8,opt,name=invite_gid" json:"invite_gid,omitempty"` + Engine *uint32 `protobuf:"varint,9,opt,name=engine" json:"engine,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAPartyInvite) Reset() { *m = CSODOTAPartyInvite{} } +func (m *CSODOTAPartyInvite) String() string { return proto.CompactTextString(m) } +func (*CSODOTAPartyInvite) ProtoMessage() {} +func (*CSODOTAPartyInvite) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{3} } + +func (m *CSODOTAPartyInvite) GetGroupId() uint64 { + if m != nil && m.GroupId != nil { + return *m.GroupId + } + return 0 +} + +func (m *CSODOTAPartyInvite) GetSenderId() uint64 { + if m != nil && m.SenderId != nil { + return *m.SenderId + } + return 0 +} + +func (m *CSODOTAPartyInvite) GetSenderName() string { + if m != nil && m.SenderName != nil { + return *m.SenderName + } + return "" +} + +func (m *CSODOTAPartyInvite) GetMembers() []*CSODOTAPartyInvite_PartyMember { + if m != nil { + return m.Members + } + return nil +} + +func (m *CSODOTAPartyInvite) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CSODOTAPartyInvite) GetLowPriorityStatus() bool { + if m != nil && m.LowPriorityStatus != nil { + return *m.LowPriorityStatus + } + return false +} + +func (m *CSODOTAPartyInvite) GetAsCoach() bool { + if m != nil && m.AsCoach != nil { + return *m.AsCoach + } + return false +} + +func (m *CSODOTAPartyInvite) GetInviteGid() uint64 { + if m != nil && m.InviteGid != nil { + return *m.InviteGid + } + return 0 +} + +func (m *CSODOTAPartyInvite) GetEngine() uint32 { + if m != nil && m.Engine != nil { + return *m.Engine + } + return 0 +} + +type CSODOTAPartyInvite_PartyMember struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + SteamId *uint64 `protobuf:"fixed64,2,opt,name=steam_id" json:"steam_id,omitempty"` + IsCoach *bool `protobuf:"varint,4,opt,name=is_coach" json:"is_coach,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAPartyInvite_PartyMember) Reset() { *m = CSODOTAPartyInvite_PartyMember{} } +func (m *CSODOTAPartyInvite_PartyMember) String() string { return proto.CompactTextString(m) } +func (*CSODOTAPartyInvite_PartyMember) ProtoMessage() {} +func (*CSODOTAPartyInvite_PartyMember) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{3, 0} +} + +func (m *CSODOTAPartyInvite_PartyMember) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CSODOTAPartyInvite_PartyMember) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CSODOTAPartyInvite_PartyMember) GetIsCoach() bool { + if m != nil && m.IsCoach != nil { + return *m.IsCoach + } + return false +} + +type CSODOTALobbyInvite struct { + GroupId *uint64 `protobuf:"varint,1,opt,name=group_id" json:"group_id,omitempty"` + SenderId *uint64 `protobuf:"fixed64,2,opt,name=sender_id" json:"sender_id,omitempty"` + SenderName *string `protobuf:"bytes,3,opt,name=sender_name" json:"sender_name,omitempty"` + Members []*CSODOTALobbyInvite_LobbyMember `protobuf:"bytes,4,rep,name=members" json:"members,omitempty"` + CustomGameId *uint64 `protobuf:"varint,5,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + InviteGid *uint64 `protobuf:"fixed64,6,opt,name=invite_gid" json:"invite_gid,omitempty"` + CustomGameCrc *uint64 `protobuf:"fixed64,7,opt,name=custom_game_crc" json:"custom_game_crc,omitempty"` + CustomGameTimestamp *uint32 `protobuf:"fixed32,8,opt,name=custom_game_timestamp" json:"custom_game_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTALobbyInvite) Reset() { *m = CSODOTALobbyInvite{} } +func (m *CSODOTALobbyInvite) String() string { return proto.CompactTextString(m) } +func (*CSODOTALobbyInvite) ProtoMessage() {} +func (*CSODOTALobbyInvite) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{4} } + +func (m *CSODOTALobbyInvite) GetGroupId() uint64 { + if m != nil && m.GroupId != nil { + return *m.GroupId + } + return 0 +} + +func (m *CSODOTALobbyInvite) GetSenderId() uint64 { + if m != nil && m.SenderId != nil { + return *m.SenderId + } + return 0 +} + +func (m *CSODOTALobbyInvite) GetSenderName() string { + if m != nil && m.SenderName != nil { + return *m.SenderName + } + return "" +} + +func (m *CSODOTALobbyInvite) GetMembers() []*CSODOTALobbyInvite_LobbyMember { + if m != nil { + return m.Members + } + return nil +} + +func (m *CSODOTALobbyInvite) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CSODOTALobbyInvite) GetInviteGid() uint64 { + if m != nil && m.InviteGid != nil { + return *m.InviteGid + } + return 0 +} + +func (m *CSODOTALobbyInvite) GetCustomGameCrc() uint64 { + if m != nil && m.CustomGameCrc != nil { + return *m.CustomGameCrc + } + return 0 +} + +func (m *CSODOTALobbyInvite) GetCustomGameTimestamp() uint32 { + if m != nil && m.CustomGameTimestamp != nil { + return *m.CustomGameTimestamp + } + return 0 +} + +type CSODOTALobbyInvite_LobbyMember struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + SteamId *uint64 `protobuf:"fixed64,2,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTALobbyInvite_LobbyMember) Reset() { *m = CSODOTALobbyInvite_LobbyMember{} } +func (m *CSODOTALobbyInvite_LobbyMember) String() string { return proto.CompactTextString(m) } +func (*CSODOTALobbyInvite_LobbyMember) ProtoMessage() {} +func (*CSODOTALobbyInvite_LobbyMember) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{4, 0} +} + +func (m *CSODOTALobbyInvite_LobbyMember) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CSODOTALobbyInvite_LobbyMember) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CDOTAClientHardwareSpecs struct { + LogicalProcessors *uint32 `protobuf:"varint,1,opt,name=logical_processors" json:"logical_processors,omitempty"` + CpuCyclesPerSecond *uint64 `protobuf:"fixed64,2,opt,name=cpu_cycles_per_second" json:"cpu_cycles_per_second,omitempty"` + TotalPhysicalMemory *uint64 `protobuf:"fixed64,3,opt,name=total_physical_memory" json:"total_physical_memory,omitempty"` + Is_64BitOs *bool `protobuf:"varint,4,opt,name=is_64_bit_os" json:"is_64_bit_os,omitempty"` + UploadMeasurement *uint64 `protobuf:"varint,5,opt,name=upload_measurement" json:"upload_measurement,omitempty"` + PreferNotHost *bool `protobuf:"varint,6,opt,name=prefer_not_host" json:"prefer_not_host,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTAClientHardwareSpecs) Reset() { *m = CDOTAClientHardwareSpecs{} } +func (m *CDOTAClientHardwareSpecs) String() string { return proto.CompactTextString(m) } +func (*CDOTAClientHardwareSpecs) ProtoMessage() {} +func (*CDOTAClientHardwareSpecs) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{5} } + +func (m *CDOTAClientHardwareSpecs) GetLogicalProcessors() uint32 { + if m != nil && m.LogicalProcessors != nil { + return *m.LogicalProcessors + } + return 0 +} + +func (m *CDOTAClientHardwareSpecs) GetCpuCyclesPerSecond() uint64 { + if m != nil && m.CpuCyclesPerSecond != nil { + return *m.CpuCyclesPerSecond + } + return 0 +} + +func (m *CDOTAClientHardwareSpecs) GetTotalPhysicalMemory() uint64 { + if m != nil && m.TotalPhysicalMemory != nil { + return *m.TotalPhysicalMemory + } + return 0 +} + +func (m *CDOTAClientHardwareSpecs) GetIs_64BitOs() bool { + if m != nil && m.Is_64BitOs != nil { + return *m.Is_64BitOs + } + return false +} + +func (m *CDOTAClientHardwareSpecs) GetUploadMeasurement() uint64 { + if m != nil && m.UploadMeasurement != nil { + return *m.UploadMeasurement + } + return 0 +} + +func (m *CDOTAClientHardwareSpecs) GetPreferNotHost() bool { + if m != nil && m.PreferNotHost != nil { + return *m.PreferNotHost + } + return false +} + +type CDOTASaveGame struct { + MatchId *uint64 `protobuf:"varint,5,opt,name=match_id" json:"match_id,omitempty"` + SaveTime *uint32 `protobuf:"varint,2,opt,name=save_time" json:"save_time,omitempty"` + Players []*CDOTASaveGame_Player `protobuf:"bytes,3,rep,name=players" json:"players,omitempty"` + SaveInstances []*CDOTASaveGame_SaveInstance `protobuf:"bytes,4,rep,name=save_instances" json:"save_instances,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTASaveGame) Reset() { *m = CDOTASaveGame{} } +func (m *CDOTASaveGame) String() string { return proto.CompactTextString(m) } +func (*CDOTASaveGame) ProtoMessage() {} +func (*CDOTASaveGame) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{6} } + +func (m *CDOTASaveGame) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CDOTASaveGame) GetSaveTime() uint32 { + if m != nil && m.SaveTime != nil { + return *m.SaveTime + } + return 0 +} + +func (m *CDOTASaveGame) GetPlayers() []*CDOTASaveGame_Player { + if m != nil { + return m.Players + } + return nil +} + +func (m *CDOTASaveGame) GetSaveInstances() []*CDOTASaveGame_SaveInstance { + if m != nil { + return m.SaveInstances + } + return nil +} + +type CDOTASaveGame_Player struct { + Team *DOTA_GC_TEAM `protobuf:"varint,1,opt,name=team,enum=DOTA_GC_TEAM,def=0" json:"team,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Hero *string `protobuf:"bytes,3,opt,name=hero" json:"hero,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTASaveGame_Player) Reset() { *m = CDOTASaveGame_Player{} } +func (m *CDOTASaveGame_Player) String() string { return proto.CompactTextString(m) } +func (*CDOTASaveGame_Player) ProtoMessage() {} +func (*CDOTASaveGame_Player) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{6, 0} } + +const Default_CDOTASaveGame_Player_Team DOTA_GC_TEAM = DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS + +func (m *CDOTASaveGame_Player) GetTeam() DOTA_GC_TEAM { + if m != nil && m.Team != nil { + return *m.Team + } + return Default_CDOTASaveGame_Player_Team +} + +func (m *CDOTASaveGame_Player) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CDOTASaveGame_Player) GetHero() string { + if m != nil && m.Hero != nil { + return *m.Hero + } + return "" +} + +type CDOTASaveGame_SaveInstance struct { + GameTime *uint32 `protobuf:"varint,2,opt,name=game_time" json:"game_time,omitempty"` + Team1Score *uint32 `protobuf:"varint,3,opt,name=team1_score" json:"team1_score,omitempty"` + Team2Score *uint32 `protobuf:"varint,4,opt,name=team2_score" json:"team2_score,omitempty"` + PlayerPositions []*CDOTASaveGame_SaveInstance_PlayerPositions `protobuf:"bytes,5,rep,name=player_positions" json:"player_positions,omitempty"` + SaveId *uint32 `protobuf:"varint,6,opt,name=save_id" json:"save_id,omitempty"` + SaveTime *uint32 `protobuf:"varint,7,opt,name=save_time" json:"save_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTASaveGame_SaveInstance) Reset() { *m = CDOTASaveGame_SaveInstance{} } +func (m *CDOTASaveGame_SaveInstance) String() string { return proto.CompactTextString(m) } +func (*CDOTASaveGame_SaveInstance) ProtoMessage() {} +func (*CDOTASaveGame_SaveInstance) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{6, 1} } + +func (m *CDOTASaveGame_SaveInstance) GetGameTime() uint32 { + if m != nil && m.GameTime != nil { + return *m.GameTime + } + return 0 +} + +func (m *CDOTASaveGame_SaveInstance) GetTeam1Score() uint32 { + if m != nil && m.Team1Score != nil { + return *m.Team1Score + } + return 0 +} + +func (m *CDOTASaveGame_SaveInstance) GetTeam2Score() uint32 { + if m != nil && m.Team2Score != nil { + return *m.Team2Score + } + return 0 +} + +func (m *CDOTASaveGame_SaveInstance) GetPlayerPositions() []*CDOTASaveGame_SaveInstance_PlayerPositions { + if m != nil { + return m.PlayerPositions + } + return nil +} + +func (m *CDOTASaveGame_SaveInstance) GetSaveId() uint32 { + if m != nil && m.SaveId != nil { + return *m.SaveId + } + return 0 +} + +func (m *CDOTASaveGame_SaveInstance) GetSaveTime() uint32 { + if m != nil && m.SaveTime != nil { + return *m.SaveTime + } + return 0 +} + +type CDOTASaveGame_SaveInstance_PlayerPositions struct { + X *float32 `protobuf:"fixed32,1,opt,name=x" json:"x,omitempty"` + Y *float32 `protobuf:"fixed32,2,opt,name=y" json:"y,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTASaveGame_SaveInstance_PlayerPositions) Reset() { + *m = CDOTASaveGame_SaveInstance_PlayerPositions{} +} +func (m *CDOTASaveGame_SaveInstance_PlayerPositions) String() string { + return proto.CompactTextString(m) +} +func (*CDOTASaveGame_SaveInstance_PlayerPositions) ProtoMessage() {} +func (*CDOTASaveGame_SaveInstance_PlayerPositions) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{6, 1, 0} +} + +func (m *CDOTASaveGame_SaveInstance_PlayerPositions) GetX() float32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *CDOTASaveGame_SaveInstance_PlayerPositions) GetY() float32 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +type CMsgLeaverState struct { + LobbyState *uint32 `protobuf:"varint,1,opt,name=lobby_state" json:"lobby_state,omitempty"` + GameState *DOTA_GameState `protobuf:"varint,2,opt,name=game_state,enum=DOTA_GameState,def=0" json:"game_state,omitempty"` + LeaverDetected *bool `protobuf:"varint,3,opt,name=leaver_detected" json:"leaver_detected,omitempty"` + FirstBloodHappened *bool `protobuf:"varint,4,opt,name=first_blood_happened" json:"first_blood_happened,omitempty"` + DiscardMatchResults *bool `protobuf:"varint,5,opt,name=discard_match_results" json:"discard_match_results,omitempty"` + MassDisconnect *bool `protobuf:"varint,6,opt,name=mass_disconnect" json:"mass_disconnect,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLeaverState) Reset() { *m = CMsgLeaverState{} } +func (m *CMsgLeaverState) String() string { return proto.CompactTextString(m) } +func (*CMsgLeaverState) ProtoMessage() {} +func (*CMsgLeaverState) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{7} } + +const Default_CMsgLeaverState_GameState DOTA_GameState = DOTA_GameState_DOTA_GAMERULES_STATE_INIT + +func (m *CMsgLeaverState) GetLobbyState() uint32 { + if m != nil && m.LobbyState != nil { + return *m.LobbyState + } + return 0 +} + +func (m *CMsgLeaverState) GetGameState() DOTA_GameState { + if m != nil && m.GameState != nil { + return *m.GameState + } + return Default_CMsgLeaverState_GameState +} + +func (m *CMsgLeaverState) GetLeaverDetected() bool { + if m != nil && m.LeaverDetected != nil { + return *m.LeaverDetected + } + return false +} + +func (m *CMsgLeaverState) GetFirstBloodHappened() bool { + if m != nil && m.FirstBloodHappened != nil { + return *m.FirstBloodHappened + } + return false +} + +func (m *CMsgLeaverState) GetDiscardMatchResults() bool { + if m != nil && m.DiscardMatchResults != nil { + return *m.DiscardMatchResults + } + return false +} + +func (m *CMsgLeaverState) GetMassDisconnect() bool { + if m != nil && m.MassDisconnect != nil { + return *m.MassDisconnect + } + return false +} + +type CDOTALobbyMember struct { + Id *uint64 `protobuf:"fixed64,1,opt,name=id" json:"id,omitempty"` + HeroId *uint32 `protobuf:"varint,2,opt,name=hero_id" json:"hero_id,omitempty"` + Team *DOTA_GC_TEAM `protobuf:"varint,3,opt,name=team,enum=DOTA_GC_TEAM,def=0" json:"team,omitempty"` + Name *string `protobuf:"bytes,6,opt,name=name" json:"name,omitempty"` + Slot *uint32 `protobuf:"varint,7,opt,name=slot" json:"slot,omitempty"` + PartyId *uint64 `protobuf:"varint,12,opt,name=party_id" json:"party_id,omitempty"` + MetaLevel *uint32 `protobuf:"varint,13,opt,name=meta_level" json:"meta_level,omitempty"` + MetaXp *uint32 `protobuf:"varint,14,opt,name=meta_xp" json:"meta_xp,omitempty"` + MetaXpAwarded *uint32 `protobuf:"varint,15,opt,name=meta_xp_awarded" json:"meta_xp_awarded,omitempty"` + LeaverStatus *DOTALeaverStatusT `protobuf:"varint,16,opt,name=leaver_status,enum=DOTALeaverStatusT,def=0" json:"leaver_status,omitempty"` + LeaverActions *uint32 `protobuf:"varint,28,opt,name=leaver_actions" json:"leaver_actions,omitempty"` + Channel *uint32 `protobuf:"varint,17,opt,name=channel" json:"channel,omitempty"` + PrizeDefIndex *uint32 `protobuf:"varint,18,opt,name=prize_def_index" json:"prize_def_index,omitempty"` + DisabledHeroId []uint32 `protobuf:"varint,20,rep,name=disabled_hero_id" json:"disabled_hero_id,omitempty"` + PartnerAccountType *PartnerAccountType `protobuf:"varint,21,opt,name=partner_account_type,enum=PartnerAccountType,def=0" json:"partner_account_type,omitempty"` + EnabledHeroId []uint32 `protobuf:"varint,22,rep,name=enabled_hero_id" json:"enabled_hero_id,omitempty"` + CoachTeam *DOTA_GC_TEAM `protobuf:"varint,23,opt,name=coach_team,enum=DOTA_GC_TEAM,def=0" json:"coach_team,omitempty"` + NexonPcBangNo *uint32 `protobuf:"varint,24,opt,name=nexon_pc_bang_no" json:"nexon_pc_bang_no,omitempty"` + NexonPcBangName *string `protobuf:"bytes,25,opt,name=nexon_pc_bang_name" json:"nexon_pc_bang_name,omitempty"` + XpBonuses []*CDOTALobbyMember_CDOTALobbyMemberXPBonus `protobuf:"bytes,27,rep,name=xp_bonuses" json:"xp_bonuses,omitempty"` + RankChange *int32 `protobuf:"zigzag32,29,opt,name=rank_change" json:"rank_change,omitempty"` + Cameraman *bool `protobuf:"varint,30,opt,name=cameraman" json:"cameraman,omitempty"` + CustomGameProductIds []uint32 `protobuf:"varint,31,rep,name=custom_game_product_ids" json:"custom_game_product_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTALobbyMember) Reset() { *m = CDOTALobbyMember{} } +func (m *CDOTALobbyMember) String() string { return proto.CompactTextString(m) } +func (*CDOTALobbyMember) ProtoMessage() {} +func (*CDOTALobbyMember) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{8} } + +const Default_CDOTALobbyMember_Team DOTA_GC_TEAM = DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS +const Default_CDOTALobbyMember_LeaverStatus DOTALeaverStatusT = DOTALeaverStatusT_DOTA_LEAVER_NONE +const Default_CDOTALobbyMember_PartnerAccountType PartnerAccountType = PartnerAccountType_PARTNER_NONE +const Default_CDOTALobbyMember_CoachTeam DOTA_GC_TEAM = DOTA_GC_TEAM_DOTA_GC_TEAM_GOOD_GUYS + +func (m *CDOTALobbyMember) GetId() uint64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CDOTALobbyMember) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CDOTALobbyMember) GetTeam() DOTA_GC_TEAM { + if m != nil && m.Team != nil { + return *m.Team + } + return Default_CDOTALobbyMember_Team +} + +func (m *CDOTALobbyMember) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CDOTALobbyMember) GetSlot() uint32 { + if m != nil && m.Slot != nil { + return *m.Slot + } + return 0 +} + +func (m *CDOTALobbyMember) GetPartyId() uint64 { + if m != nil && m.PartyId != nil { + return *m.PartyId + } + return 0 +} + +func (m *CDOTALobbyMember) GetMetaLevel() uint32 { + if m != nil && m.MetaLevel != nil { + return *m.MetaLevel + } + return 0 +} + +func (m *CDOTALobbyMember) GetMetaXp() uint32 { + if m != nil && m.MetaXp != nil { + return *m.MetaXp + } + return 0 +} + +func (m *CDOTALobbyMember) GetMetaXpAwarded() uint32 { + if m != nil && m.MetaXpAwarded != nil { + return *m.MetaXpAwarded + } + return 0 +} + +func (m *CDOTALobbyMember) GetLeaverStatus() DOTALeaverStatusT { + if m != nil && m.LeaverStatus != nil { + return *m.LeaverStatus + } + return Default_CDOTALobbyMember_LeaverStatus +} + +func (m *CDOTALobbyMember) GetLeaverActions() uint32 { + if m != nil && m.LeaverActions != nil { + return *m.LeaverActions + } + return 0 +} + +func (m *CDOTALobbyMember) GetChannel() uint32 { + if m != nil && m.Channel != nil { + return *m.Channel + } + return 0 +} + +func (m *CDOTALobbyMember) GetPrizeDefIndex() uint32 { + if m != nil && m.PrizeDefIndex != nil { + return *m.PrizeDefIndex + } + return 0 +} + +func (m *CDOTALobbyMember) GetDisabledHeroId() []uint32 { + if m != nil { + return m.DisabledHeroId + } + return nil +} + +func (m *CDOTALobbyMember) GetPartnerAccountType() PartnerAccountType { + if m != nil && m.PartnerAccountType != nil { + return *m.PartnerAccountType + } + return Default_CDOTALobbyMember_PartnerAccountType +} + +func (m *CDOTALobbyMember) GetEnabledHeroId() []uint32 { + if m != nil { + return m.EnabledHeroId + } + return nil +} + +func (m *CDOTALobbyMember) GetCoachTeam() DOTA_GC_TEAM { + if m != nil && m.CoachTeam != nil { + return *m.CoachTeam + } + return Default_CDOTALobbyMember_CoachTeam +} + +func (m *CDOTALobbyMember) GetNexonPcBangNo() uint32 { + if m != nil && m.NexonPcBangNo != nil { + return *m.NexonPcBangNo + } + return 0 +} + +func (m *CDOTALobbyMember) GetNexonPcBangName() string { + if m != nil && m.NexonPcBangName != nil { + return *m.NexonPcBangName + } + return "" +} + +func (m *CDOTALobbyMember) GetXpBonuses() []*CDOTALobbyMember_CDOTALobbyMemberXPBonus { + if m != nil { + return m.XpBonuses + } + return nil +} + +func (m *CDOTALobbyMember) GetRankChange() int32 { + if m != nil && m.RankChange != nil { + return *m.RankChange + } + return 0 +} + +func (m *CDOTALobbyMember) GetCameraman() bool { + if m != nil && m.Cameraman != nil { + return *m.Cameraman + } + return false +} + +func (m *CDOTALobbyMember) GetCustomGameProductIds() []uint32 { + if m != nil { + return m.CustomGameProductIds + } + return nil +} + +type CDOTALobbyMember_CDOTALobbyMemberXPBonus struct { + Type *uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + XpBonus *float32 `protobuf:"fixed32,2,opt,name=xp_bonus" json:"xp_bonus,omitempty"` + SourceKey *uint64 `protobuf:"varint,3,opt,name=source_key" json:"source_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDOTALobbyMember_CDOTALobbyMemberXPBonus) Reset() { + *m = CDOTALobbyMember_CDOTALobbyMemberXPBonus{} +} +func (m *CDOTALobbyMember_CDOTALobbyMemberXPBonus) String() string { return proto.CompactTextString(m) } +func (*CDOTALobbyMember_CDOTALobbyMemberXPBonus) ProtoMessage() {} +func (*CDOTALobbyMember_CDOTALobbyMemberXPBonus) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{8, 0} +} + +func (m *CDOTALobbyMember_CDOTALobbyMemberXPBonus) GetType() uint32 { + if m != nil && m.Type != nil { + return *m.Type + } + return 0 +} + +func (m *CDOTALobbyMember_CDOTALobbyMemberXPBonus) GetXpBonus() float32 { + if m != nil && m.XpBonus != nil { + return *m.XpBonus + } + return 0 +} + +func (m *CDOTALobbyMember_CDOTALobbyMemberXPBonus) GetSourceKey() uint64 { + if m != nil && m.SourceKey != nil { + return *m.SourceKey + } + return 0 +} + +type CLobbyTeamDetails struct { + TeamName *string `protobuf:"bytes,1,opt,name=team_name" json:"team_name,omitempty"` + TeamTag *string `protobuf:"bytes,3,opt,name=team_tag" json:"team_tag,omitempty"` + TeamId *uint32 `protobuf:"varint,4,opt,name=team_id" json:"team_id,omitempty"` + TeamLogo *uint64 `protobuf:"varint,5,opt,name=team_logo" json:"team_logo,omitempty"` + TeamBaseLogo *uint64 `protobuf:"varint,6,opt,name=team_base_logo" json:"team_base_logo,omitempty"` + TeamBannerLogo *uint64 `protobuf:"varint,7,opt,name=team_banner_logo" json:"team_banner_logo,omitempty"` + TeamComplete *bool `protobuf:"varint,8,opt,name=team_complete" json:"team_complete,omitempty"` + GuildName *string `protobuf:"bytes,9,opt,name=guild_name" json:"guild_name,omitempty"` + GuildTag *string `protobuf:"bytes,10,opt,name=guild_tag" json:"guild_tag,omitempty"` + GuildId *uint32 `protobuf:"varint,11,opt,name=guild_id" json:"guild_id,omitempty"` + GuildLogo *uint64 `protobuf:"varint,12,opt,name=guild_logo" json:"guild_logo,omitempty"` + GuildBaseLogo *uint64 `protobuf:"varint,13,opt,name=guild_base_logo" json:"guild_base_logo,omitempty"` + GuildBannerLogo *uint64 `protobuf:"varint,14,opt,name=guild_banner_logo" json:"guild_banner_logo,omitempty"` + Rank *uint32 `protobuf:"varint,15,opt,name=rank" json:"rank,omitempty"` + RankChange *int32 `protobuf:"zigzag32,16,opt,name=rank_change" json:"rank_change,omitempty"` + IsHomeTeam *bool `protobuf:"varint,17,opt,name=is_home_team" json:"is_home_team,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CLobbyTeamDetails) Reset() { *m = CLobbyTeamDetails{} } +func (m *CLobbyTeamDetails) String() string { return proto.CompactTextString(m) } +func (*CLobbyTeamDetails) ProtoMessage() {} +func (*CLobbyTeamDetails) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{9} } + +func (m *CLobbyTeamDetails) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CLobbyTeamDetails) GetTeamTag() string { + if m != nil && m.TeamTag != nil { + return *m.TeamTag + } + return "" +} + +func (m *CLobbyTeamDetails) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CLobbyTeamDetails) GetTeamLogo() uint64 { + if m != nil && m.TeamLogo != nil { + return *m.TeamLogo + } + return 0 +} + +func (m *CLobbyTeamDetails) GetTeamBaseLogo() uint64 { + if m != nil && m.TeamBaseLogo != nil { + return *m.TeamBaseLogo + } + return 0 +} + +func (m *CLobbyTeamDetails) GetTeamBannerLogo() uint64 { + if m != nil && m.TeamBannerLogo != nil { + return *m.TeamBannerLogo + } + return 0 +} + +func (m *CLobbyTeamDetails) GetTeamComplete() bool { + if m != nil && m.TeamComplete != nil { + return *m.TeamComplete + } + return false +} + +func (m *CLobbyTeamDetails) GetGuildName() string { + if m != nil && m.GuildName != nil { + return *m.GuildName + } + return "" +} + +func (m *CLobbyTeamDetails) GetGuildTag() string { + if m != nil && m.GuildTag != nil { + return *m.GuildTag + } + return "" +} + +func (m *CLobbyTeamDetails) GetGuildId() uint32 { + if m != nil && m.GuildId != nil { + return *m.GuildId + } + return 0 +} + +func (m *CLobbyTeamDetails) GetGuildLogo() uint64 { + if m != nil && m.GuildLogo != nil { + return *m.GuildLogo + } + return 0 +} + +func (m *CLobbyTeamDetails) GetGuildBaseLogo() uint64 { + if m != nil && m.GuildBaseLogo != nil { + return *m.GuildBaseLogo + } + return 0 +} + +func (m *CLobbyTeamDetails) GetGuildBannerLogo() uint64 { + if m != nil && m.GuildBannerLogo != nil { + return *m.GuildBannerLogo + } + return 0 +} + +func (m *CLobbyTeamDetails) GetRank() uint32 { + if m != nil && m.Rank != nil { + return *m.Rank + } + return 0 +} + +func (m *CLobbyTeamDetails) GetRankChange() int32 { + if m != nil && m.RankChange != nil { + return *m.RankChange + } + return 0 +} + +func (m *CLobbyTeamDetails) GetIsHomeTeam() bool { + if m != nil && m.IsHomeTeam != nil { + return *m.IsHomeTeam + } + return false +} + +type CLobbyTimedRewardDetails struct { + ItemDefIndex *uint32 `protobuf:"varint,2,opt,name=item_def_index" json:"item_def_index,omitempty"` + IsSupplyCrate *bool `protobuf:"varint,3,opt,name=is_supply_crate" json:"is_supply_crate,omitempty"` + IsTimedDrop *bool `protobuf:"varint,4,opt,name=is_timed_drop" json:"is_timed_drop,omitempty"` + AccountId *uint32 `protobuf:"varint,5,opt,name=account_id" json:"account_id,omitempty"` + Origin *uint32 `protobuf:"varint,6,opt,name=origin" json:"origin,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CLobbyTimedRewardDetails) Reset() { *m = CLobbyTimedRewardDetails{} } +func (m *CLobbyTimedRewardDetails) String() string { return proto.CompactTextString(m) } +func (*CLobbyTimedRewardDetails) ProtoMessage() {} +func (*CLobbyTimedRewardDetails) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{10} } + +func (m *CLobbyTimedRewardDetails) GetItemDefIndex() uint32 { + if m != nil && m.ItemDefIndex != nil { + return *m.ItemDefIndex + } + return 0 +} + +func (m *CLobbyTimedRewardDetails) GetIsSupplyCrate() bool { + if m != nil && m.IsSupplyCrate != nil { + return *m.IsSupplyCrate + } + return false +} + +func (m *CLobbyTimedRewardDetails) GetIsTimedDrop() bool { + if m != nil && m.IsTimedDrop != nil { + return *m.IsTimedDrop + } + return false +} + +func (m *CLobbyTimedRewardDetails) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CLobbyTimedRewardDetails) GetOrigin() uint32 { + if m != nil && m.Origin != nil { + return *m.Origin + } + return 0 +} + +type CLobbyBroadcastChannelInfo struct { + ChannelId *uint32 `protobuf:"varint,1,opt,name=channel_id" json:"channel_id,omitempty"` + CountryCode *string `protobuf:"bytes,2,opt,name=country_code" json:"country_code,omitempty"` + Description *string `protobuf:"bytes,3,opt,name=description" json:"description,omitempty"` + LanguageCode *string `protobuf:"bytes,4,opt,name=language_code" json:"language_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CLobbyBroadcastChannelInfo) Reset() { *m = CLobbyBroadcastChannelInfo{} } +func (m *CLobbyBroadcastChannelInfo) String() string { return proto.CompactTextString(m) } +func (*CLobbyBroadcastChannelInfo) ProtoMessage() {} +func (*CLobbyBroadcastChannelInfo) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{11} } + +func (m *CLobbyBroadcastChannelInfo) GetChannelId() uint32 { + if m != nil && m.ChannelId != nil { + return *m.ChannelId + } + return 0 +} + +func (m *CLobbyBroadcastChannelInfo) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CLobbyBroadcastChannelInfo) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CLobbyBroadcastChannelInfo) GetLanguageCode() string { + if m != nil && m.LanguageCode != nil { + return *m.LanguageCode + } + return "" +} + +type CSODOTALobby struct { + LobbyId *uint64 `protobuf:"varint,1,opt,name=lobby_id" json:"lobby_id,omitempty"` + Members []*CDOTALobbyMember `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"` + LeftMembers []*CDOTALobbyMember `protobuf:"bytes,7,rep,name=left_members" json:"left_members,omitempty"` + LeaderId *uint64 `protobuf:"fixed64,11,opt,name=leader_id" json:"leader_id,omitempty"` + ServerId *uint64 `protobuf:"fixed64,6,opt,name=server_id,def=0" json:"server_id,omitempty"` + GameMode *uint32 `protobuf:"varint,3,opt,name=game_mode" json:"game_mode,omitempty"` + PendingInvites []uint64 `protobuf:"fixed64,10,rep,name=pending_invites" json:"pending_invites,omitempty"` + State *CSODOTALobby_State `protobuf:"varint,4,opt,name=state,enum=CSODOTALobby_State,def=0" json:"state,omitempty"` + Connect *string `protobuf:"bytes,5,opt,name=connect" json:"connect,omitempty"` + LobbyType *CSODOTALobby_LobbyType `protobuf:"varint,12,opt,name=lobby_type,enum=CSODOTALobby_LobbyType,def=-1" json:"lobby_type,omitempty"` + AllowCheats *bool `protobuf:"varint,13,opt,name=allow_cheats" json:"allow_cheats,omitempty"` + FillWithBots *bool `protobuf:"varint,14,opt,name=fill_with_bots" json:"fill_with_bots,omitempty"` + IntroMode *bool `protobuf:"varint,15,opt,name=intro_mode" json:"intro_mode,omitempty"` + GameName *string `protobuf:"bytes,16,opt,name=game_name" json:"game_name,omitempty"` + TeamDetails []*CLobbyTeamDetails `protobuf:"bytes,17,rep,name=team_details" json:"team_details,omitempty"` + TutorialLesson *uint32 `protobuf:"varint,18,opt,name=tutorial_lesson" json:"tutorial_lesson,omitempty"` + TournamentId *uint32 `protobuf:"varint,19,opt,name=tournament_id" json:"tournament_id,omitempty"` + TournamentGameId *uint32 `protobuf:"varint,20,opt,name=tournament_game_id" json:"tournament_game_id,omitempty"` + ServerRegion *uint32 `protobuf:"varint,21,opt,name=server_region,def=0" json:"server_region,omitempty"` + GameState *DOTA_GameState `protobuf:"varint,22,opt,name=game_state,enum=DOTA_GameState,def=0" json:"game_state,omitempty"` + NumSpectators *uint32 `protobuf:"varint,23,opt,name=num_spectators" json:"num_spectators,omitempty"` + Matchgroup *uint32 `protobuf:"varint,25,opt,name=matchgroup" json:"matchgroup,omitempty"` + CmPick *DOTA_CM_PICK `protobuf:"varint,28,opt,name=cm_pick,enum=DOTA_CM_PICK,def=0" json:"cm_pick,omitempty"` + MatchId *uint64 `protobuf:"varint,30,opt,name=match_id" json:"match_id,omitempty"` + AllowSpectating *bool `protobuf:"varint,31,opt,name=allow_spectating,def=1" json:"allow_spectating,omitempty"` + BotDifficulty *DOTABotDifficulty `protobuf:"varint,36,opt,name=bot_difficulty,enum=DOTABotDifficulty,def=3" json:"bot_difficulty,omitempty"` + GameVersion *DOTAGameVersion `protobuf:"varint,37,opt,name=game_version,enum=DOTAGameVersion,def=0" json:"game_version,omitempty"` + TimedRewardDetails []*CLobbyTimedRewardDetails `protobuf:"bytes,38,rep,name=timed_reward_details" json:"timed_reward_details,omitempty"` + PassKey *string `protobuf:"bytes,39,opt,name=pass_key" json:"pass_key,omitempty"` + BotSlotDifficulty []DOTABotDifficulty `protobuf:"varint,41,rep,name=bot_slot_difficulty,enum=DOTABotDifficulty" json:"bot_slot_difficulty,omitempty"` + Leagueid *uint32 `protobuf:"varint,42,opt,name=leagueid" json:"leagueid,omitempty"` + PenaltyLevelRadiant *uint32 `protobuf:"varint,43,opt,name=penalty_level_radiant,def=0" json:"penalty_level_radiant,omitempty"` + PenaltyLevelDire *uint32 `protobuf:"varint,44,opt,name=penalty_level_dire,def=0" json:"penalty_level_dire,omitempty"` + LoadGameId *uint32 `protobuf:"varint,45,opt,name=load_game_id" json:"load_game_id,omitempty"` + SeriesType *uint32 `protobuf:"varint,46,opt,name=series_type" json:"series_type,omitempty"` + RadiantSeriesWins *uint32 `protobuf:"varint,47,opt,name=radiant_series_wins" json:"radiant_series_wins,omitempty"` + DireSeriesWins *uint32 `protobuf:"varint,48,opt,name=dire_series_wins" json:"dire_series_wins,omitempty"` + LootGenerated *uint32 `protobuf:"varint,49,opt,name=loot_generated" json:"loot_generated,omitempty"` + LootAwarded *uint32 `protobuf:"varint,50,opt,name=loot_awarded" json:"loot_awarded,omitempty"` + Allchat *bool `protobuf:"varint,51,opt,name=allchat,def=0" json:"allchat,omitempty"` + DotaTvDelay *LobbyDotaTVDelay `protobuf:"varint,53,opt,name=dota_tv_delay,enum=LobbyDotaTVDelay,def=0" json:"dota_tv_delay,omitempty"` + CustomGameMode *string `protobuf:"bytes,54,opt,name=custom_game_mode" json:"custom_game_mode,omitempty"` + CustomMapName *string `protobuf:"bytes,55,opt,name=custom_map_name" json:"custom_map_name,omitempty"` + CustomDifficulty *uint32 `protobuf:"varint,56,opt,name=custom_difficulty" json:"custom_difficulty,omitempty"` + Lan *bool `protobuf:"varint,57,opt,name=lan" json:"lan,omitempty"` + BroadcastChannelInfo []*CLobbyBroadcastChannelInfo `protobuf:"bytes,58,rep,name=broadcast_channel_info" json:"broadcast_channel_info,omitempty"` + FirstLeaverAccountid *uint32 `protobuf:"varint,59,opt,name=first_leaver_accountid" json:"first_leaver_accountid,omitempty"` + SeriesId *uint32 `protobuf:"varint,60,opt,name=series_id" json:"series_id,omitempty"` + LowPriority *bool `protobuf:"varint,61,opt,name=low_priority" json:"low_priority,omitempty"` + ExtraMessages []*CSODOTALobby_CExtraMsg `protobuf:"bytes,62,rep,name=extra_messages" json:"extra_messages,omitempty"` + SaveGame *CDOTASaveGame `protobuf:"bytes,63,opt,name=save_game" json:"save_game,omitempty"` + FirstBloodHappened *bool `protobuf:"varint,65,opt,name=first_blood_happened" json:"first_blood_happened,omitempty"` + MatchOutcome *EMatchOutcome `protobuf:"varint,70,opt,name=match_outcome,enum=EMatchOutcome,def=0" json:"match_outcome,omitempty"` + MassDisconnect *bool `protobuf:"varint,67,opt,name=mass_disconnect" json:"mass_disconnect,omitempty"` + CustomGameId *uint64 `protobuf:"varint,68,opt,name=custom_game_id" json:"custom_game_id,omitempty"` + ActiveIngameEvents []EEvent `protobuf:"varint,69,rep,name=active_ingame_events,enum=EEvent" json:"active_ingame_events,omitempty"` + CustomMinPlayers *uint32 `protobuf:"varint,71,opt,name=custom_min_players" json:"custom_min_players,omitempty"` + CustomMaxPlayers *uint32 `protobuf:"varint,72,opt,name=custom_max_players" json:"custom_max_players,omitempty"` + PartnerType *PartnerAccountType `protobuf:"varint,73,opt,name=partner_type,enum=PartnerAccountType,def=0" json:"partner_type,omitempty"` + LanHostPingToServerRegion *uint32 `protobuf:"varint,74,opt,name=lan_host_ping_to_server_region" json:"lan_host_ping_to_server_region,omitempty"` + Visibility *DOTALobbyVisibility `protobuf:"varint,75,opt,name=visibility,enum=DOTALobbyVisibility,def=0" json:"visibility,omitempty"` + CustomGameCrc *uint64 `protobuf:"fixed64,76,opt,name=custom_game_crc" json:"custom_game_crc,omitempty"` + CustomGameAutoCreatedLobby *bool `protobuf:"varint,77,opt,name=custom_game_auto_created_lobby" json:"custom_game_auto_created_lobby,omitempty"` + LeagueSeriesId *uint32 `protobuf:"varint,78,opt,name=league_series_id" json:"league_series_id,omitempty"` + LeagueGameId *uint32 `protobuf:"varint,79,opt,name=league_game_id" json:"league_game_id,omitempty"` + CustomGameTimestamp *uint32 `protobuf:"fixed32,80,opt,name=custom_game_timestamp" json:"custom_game_timestamp,omitempty"` + PreviousSeriesMatches []uint64 `protobuf:"varint,81,rep,name=previous_series_matches" json:"previous_series_matches,omitempty"` + PreviousMatchOverride *uint64 `protobuf:"varint,82,opt,name=previous_match_override" json:"previous_match_override,omitempty"` + CustomGameUsesAccountRecords *bool `protobuf:"varint,83,opt,name=custom_game_uses_account_records" json:"custom_game_uses_account_records,omitempty"` + LeagueSelectionPriorityTeam *uint32 `protobuf:"varint,84,opt,name=league_selection_priority_team" json:"league_selection_priority_team,omitempty"` + LeagueSelectionPriorityChoice *SelectionPriorityType `protobuf:"varint,85,opt,name=league_selection_priority_choice,enum=SelectionPriorityType,def=0" json:"league_selection_priority_choice,omitempty"` + LeagueNonSelectionPriorityChoice *SelectionPriorityType `protobuf:"varint,86,opt,name=league_non_selection_priority_choice,enum=SelectionPriorityType,def=0" json:"league_non_selection_priority_choice,omitempty"` + GameStartTime *uint32 `protobuf:"varint,87,opt,name=game_start_time" json:"game_start_time,omitempty"` + PauseSetting *LobbyDotaPauseSetting `protobuf:"varint,88,opt,name=pause_setting,enum=LobbyDotaPauseSetting,def=0" json:"pause_setting,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTALobby) Reset() { *m = CSODOTALobby{} } +func (m *CSODOTALobby) String() string { return proto.CompactTextString(m) } +func (*CSODOTALobby) ProtoMessage() {} +func (*CSODOTALobby) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{12} } + +const Default_CSODOTALobby_ServerId uint64 = 0 +const Default_CSODOTALobby_State CSODOTALobby_State = CSODOTALobby_UI +const Default_CSODOTALobby_LobbyType CSODOTALobby_LobbyType = CSODOTALobby_INVALID +const Default_CSODOTALobby_ServerRegion uint32 = 0 +const Default_CSODOTALobby_GameState DOTA_GameState = DOTA_GameState_DOTA_GAMERULES_STATE_INIT +const Default_CSODOTALobby_CmPick DOTA_CM_PICK = DOTA_CM_PICK_DOTA_CM_RANDOM +const Default_CSODOTALobby_AllowSpectating bool = true +const Default_CSODOTALobby_BotDifficulty DOTABotDifficulty = DOTABotDifficulty_BOT_DIFFICULTY_HARD +const Default_CSODOTALobby_GameVersion DOTAGameVersion = DOTAGameVersion_GAME_VERSION_CURRENT +const Default_CSODOTALobby_PenaltyLevelRadiant uint32 = 0 +const Default_CSODOTALobby_PenaltyLevelDire uint32 = 0 +const Default_CSODOTALobby_Allchat bool = false +const Default_CSODOTALobby_DotaTvDelay LobbyDotaTVDelay = LobbyDotaTVDelay_LobbyDotaTV_10 +const Default_CSODOTALobby_MatchOutcome EMatchOutcome = EMatchOutcome_k_EMatchOutcome_Unknown +const Default_CSODOTALobby_PartnerType PartnerAccountType = PartnerAccountType_PARTNER_NONE +const Default_CSODOTALobby_Visibility DOTALobbyVisibility = DOTALobbyVisibility_DOTALobbyVisibility_Public +const Default_CSODOTALobby_LeagueSelectionPriorityChoice SelectionPriorityType = SelectionPriorityType_UNDEFINED +const Default_CSODOTALobby_LeagueNonSelectionPriorityChoice SelectionPriorityType = SelectionPriorityType_UNDEFINED +const Default_CSODOTALobby_PauseSetting LobbyDotaPauseSetting = LobbyDotaPauseSetting_LobbyDotaPauseSetting_Unlimited + +func (m *CSODOTALobby) GetLobbyId() uint64 { + if m != nil && m.LobbyId != nil { + return *m.LobbyId + } + return 0 +} + +func (m *CSODOTALobby) GetMembers() []*CDOTALobbyMember { + if m != nil { + return m.Members + } + return nil +} + +func (m *CSODOTALobby) GetLeftMembers() []*CDOTALobbyMember { + if m != nil { + return m.LeftMembers + } + return nil +} + +func (m *CSODOTALobby) GetLeaderId() uint64 { + if m != nil && m.LeaderId != nil { + return *m.LeaderId + } + return 0 +} + +func (m *CSODOTALobby) GetServerId() uint64 { + if m != nil && m.ServerId != nil { + return *m.ServerId + } + return Default_CSODOTALobby_ServerId +} + +func (m *CSODOTALobby) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CSODOTALobby) GetPendingInvites() []uint64 { + if m != nil { + return m.PendingInvites + } + return nil +} + +func (m *CSODOTALobby) GetState() CSODOTALobby_State { + if m != nil && m.State != nil { + return *m.State + } + return Default_CSODOTALobby_State +} + +func (m *CSODOTALobby) GetConnect() string { + if m != nil && m.Connect != nil { + return *m.Connect + } + return "" +} + +func (m *CSODOTALobby) GetLobbyType() CSODOTALobby_LobbyType { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return Default_CSODOTALobby_LobbyType +} + +func (m *CSODOTALobby) GetAllowCheats() bool { + if m != nil && m.AllowCheats != nil { + return *m.AllowCheats + } + return false +} + +func (m *CSODOTALobby) GetFillWithBots() bool { + if m != nil && m.FillWithBots != nil { + return *m.FillWithBots + } + return false +} + +func (m *CSODOTALobby) GetIntroMode() bool { + if m != nil && m.IntroMode != nil { + return *m.IntroMode + } + return false +} + +func (m *CSODOTALobby) GetGameName() string { + if m != nil && m.GameName != nil { + return *m.GameName + } + return "" +} + +func (m *CSODOTALobby) GetTeamDetails() []*CLobbyTeamDetails { + if m != nil { + return m.TeamDetails + } + return nil +} + +func (m *CSODOTALobby) GetTutorialLesson() uint32 { + if m != nil && m.TutorialLesson != nil { + return *m.TutorialLesson + } + return 0 +} + +func (m *CSODOTALobby) GetTournamentId() uint32 { + if m != nil && m.TournamentId != nil { + return *m.TournamentId + } + return 0 +} + +func (m *CSODOTALobby) GetTournamentGameId() uint32 { + if m != nil && m.TournamentGameId != nil { + return *m.TournamentGameId + } + return 0 +} + +func (m *CSODOTALobby) GetServerRegion() uint32 { + if m != nil && m.ServerRegion != nil { + return *m.ServerRegion + } + return Default_CSODOTALobby_ServerRegion +} + +func (m *CSODOTALobby) GetGameState() DOTA_GameState { + if m != nil && m.GameState != nil { + return *m.GameState + } + return Default_CSODOTALobby_GameState +} + +func (m *CSODOTALobby) GetNumSpectators() uint32 { + if m != nil && m.NumSpectators != nil { + return *m.NumSpectators + } + return 0 +} + +func (m *CSODOTALobby) GetMatchgroup() uint32 { + if m != nil && m.Matchgroup != nil { + return *m.Matchgroup + } + return 0 +} + +func (m *CSODOTALobby) GetCmPick() DOTA_CM_PICK { + if m != nil && m.CmPick != nil { + return *m.CmPick + } + return Default_CSODOTALobby_CmPick +} + +func (m *CSODOTALobby) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CSODOTALobby) GetAllowSpectating() bool { + if m != nil && m.AllowSpectating != nil { + return *m.AllowSpectating + } + return Default_CSODOTALobby_AllowSpectating +} + +func (m *CSODOTALobby) GetBotDifficulty() DOTABotDifficulty { + if m != nil && m.BotDifficulty != nil { + return *m.BotDifficulty + } + return Default_CSODOTALobby_BotDifficulty +} + +func (m *CSODOTALobby) GetGameVersion() DOTAGameVersion { + if m != nil && m.GameVersion != nil { + return *m.GameVersion + } + return Default_CSODOTALobby_GameVersion +} + +func (m *CSODOTALobby) GetTimedRewardDetails() []*CLobbyTimedRewardDetails { + if m != nil { + return m.TimedRewardDetails + } + return nil +} + +func (m *CSODOTALobby) GetPassKey() string { + if m != nil && m.PassKey != nil { + return *m.PassKey + } + return "" +} + +func (m *CSODOTALobby) GetBotSlotDifficulty() []DOTABotDifficulty { + if m != nil { + return m.BotSlotDifficulty + } + return nil +} + +func (m *CSODOTALobby) GetLeagueid() uint32 { + if m != nil && m.Leagueid != nil { + return *m.Leagueid + } + return 0 +} + +func (m *CSODOTALobby) GetPenaltyLevelRadiant() uint32 { + if m != nil && m.PenaltyLevelRadiant != nil { + return *m.PenaltyLevelRadiant + } + return Default_CSODOTALobby_PenaltyLevelRadiant +} + +func (m *CSODOTALobby) GetPenaltyLevelDire() uint32 { + if m != nil && m.PenaltyLevelDire != nil { + return *m.PenaltyLevelDire + } + return Default_CSODOTALobby_PenaltyLevelDire +} + +func (m *CSODOTALobby) GetLoadGameId() uint32 { + if m != nil && m.LoadGameId != nil { + return *m.LoadGameId + } + return 0 +} + +func (m *CSODOTALobby) GetSeriesType() uint32 { + if m != nil && m.SeriesType != nil { + return *m.SeriesType + } + return 0 +} + +func (m *CSODOTALobby) GetRadiantSeriesWins() uint32 { + if m != nil && m.RadiantSeriesWins != nil { + return *m.RadiantSeriesWins + } + return 0 +} + +func (m *CSODOTALobby) GetDireSeriesWins() uint32 { + if m != nil && m.DireSeriesWins != nil { + return *m.DireSeriesWins + } + return 0 +} + +func (m *CSODOTALobby) GetLootGenerated() uint32 { + if m != nil && m.LootGenerated != nil { + return *m.LootGenerated + } + return 0 +} + +func (m *CSODOTALobby) GetLootAwarded() uint32 { + if m != nil && m.LootAwarded != nil { + return *m.LootAwarded + } + return 0 +} + +func (m *CSODOTALobby) GetAllchat() bool { + if m != nil && m.Allchat != nil { + return *m.Allchat + } + return Default_CSODOTALobby_Allchat +} + +func (m *CSODOTALobby) GetDotaTvDelay() LobbyDotaTVDelay { + if m != nil && m.DotaTvDelay != nil { + return *m.DotaTvDelay + } + return Default_CSODOTALobby_DotaTvDelay +} + +func (m *CSODOTALobby) GetCustomGameMode() string { + if m != nil && m.CustomGameMode != nil { + return *m.CustomGameMode + } + return "" +} + +func (m *CSODOTALobby) GetCustomMapName() string { + if m != nil && m.CustomMapName != nil { + return *m.CustomMapName + } + return "" +} + +func (m *CSODOTALobby) GetCustomDifficulty() uint32 { + if m != nil && m.CustomDifficulty != nil { + return *m.CustomDifficulty + } + return 0 +} + +func (m *CSODOTALobby) GetLan() bool { + if m != nil && m.Lan != nil { + return *m.Lan + } + return false +} + +func (m *CSODOTALobby) GetBroadcastChannelInfo() []*CLobbyBroadcastChannelInfo { + if m != nil { + return m.BroadcastChannelInfo + } + return nil +} + +func (m *CSODOTALobby) GetFirstLeaverAccountid() uint32 { + if m != nil && m.FirstLeaverAccountid != nil { + return *m.FirstLeaverAccountid + } + return 0 +} + +func (m *CSODOTALobby) GetSeriesId() uint32 { + if m != nil && m.SeriesId != nil { + return *m.SeriesId + } + return 0 +} + +func (m *CSODOTALobby) GetLowPriority() bool { + if m != nil && m.LowPriority != nil { + return *m.LowPriority + } + return false +} + +func (m *CSODOTALobby) GetExtraMessages() []*CSODOTALobby_CExtraMsg { + if m != nil { + return m.ExtraMessages + } + return nil +} + +func (m *CSODOTALobby) GetSaveGame() *CDOTASaveGame { + if m != nil { + return m.SaveGame + } + return nil +} + +func (m *CSODOTALobby) GetFirstBloodHappened() bool { + if m != nil && m.FirstBloodHappened != nil { + return *m.FirstBloodHappened + } + return false +} + +func (m *CSODOTALobby) GetMatchOutcome() EMatchOutcome { + if m != nil && m.MatchOutcome != nil { + return *m.MatchOutcome + } + return Default_CSODOTALobby_MatchOutcome +} + +func (m *CSODOTALobby) GetMassDisconnect() bool { + if m != nil && m.MassDisconnect != nil { + return *m.MassDisconnect + } + return false +} + +func (m *CSODOTALobby) GetCustomGameId() uint64 { + if m != nil && m.CustomGameId != nil { + return *m.CustomGameId + } + return 0 +} + +func (m *CSODOTALobby) GetActiveIngameEvents() []EEvent { + if m != nil { + return m.ActiveIngameEvents + } + return nil +} + +func (m *CSODOTALobby) GetCustomMinPlayers() uint32 { + if m != nil && m.CustomMinPlayers != nil { + return *m.CustomMinPlayers + } + return 0 +} + +func (m *CSODOTALobby) GetCustomMaxPlayers() uint32 { + if m != nil && m.CustomMaxPlayers != nil { + return *m.CustomMaxPlayers + } + return 0 +} + +func (m *CSODOTALobby) GetPartnerType() PartnerAccountType { + if m != nil && m.PartnerType != nil { + return *m.PartnerType + } + return Default_CSODOTALobby_PartnerType +} + +func (m *CSODOTALobby) GetLanHostPingToServerRegion() uint32 { + if m != nil && m.LanHostPingToServerRegion != nil { + return *m.LanHostPingToServerRegion + } + return 0 +} + +func (m *CSODOTALobby) GetVisibility() DOTALobbyVisibility { + if m != nil && m.Visibility != nil { + return *m.Visibility + } + return Default_CSODOTALobby_Visibility +} + +func (m *CSODOTALobby) GetCustomGameCrc() uint64 { + if m != nil && m.CustomGameCrc != nil { + return *m.CustomGameCrc + } + return 0 +} + +func (m *CSODOTALobby) GetCustomGameAutoCreatedLobby() bool { + if m != nil && m.CustomGameAutoCreatedLobby != nil { + return *m.CustomGameAutoCreatedLobby + } + return false +} + +func (m *CSODOTALobby) GetLeagueSeriesId() uint32 { + if m != nil && m.LeagueSeriesId != nil { + return *m.LeagueSeriesId + } + return 0 +} + +func (m *CSODOTALobby) GetLeagueGameId() uint32 { + if m != nil && m.LeagueGameId != nil { + return *m.LeagueGameId + } + return 0 +} + +func (m *CSODOTALobby) GetCustomGameTimestamp() uint32 { + if m != nil && m.CustomGameTimestamp != nil { + return *m.CustomGameTimestamp + } + return 0 +} + +func (m *CSODOTALobby) GetPreviousSeriesMatches() []uint64 { + if m != nil { + return m.PreviousSeriesMatches + } + return nil +} + +func (m *CSODOTALobby) GetPreviousMatchOverride() uint64 { + if m != nil && m.PreviousMatchOverride != nil { + return *m.PreviousMatchOverride + } + return 0 +} + +func (m *CSODOTALobby) GetCustomGameUsesAccountRecords() bool { + if m != nil && m.CustomGameUsesAccountRecords != nil { + return *m.CustomGameUsesAccountRecords + } + return false +} + +func (m *CSODOTALobby) GetLeagueSelectionPriorityTeam() uint32 { + if m != nil && m.LeagueSelectionPriorityTeam != nil { + return *m.LeagueSelectionPriorityTeam + } + return 0 +} + +func (m *CSODOTALobby) GetLeagueSelectionPriorityChoice() SelectionPriorityType { + if m != nil && m.LeagueSelectionPriorityChoice != nil { + return *m.LeagueSelectionPriorityChoice + } + return Default_CSODOTALobby_LeagueSelectionPriorityChoice +} + +func (m *CSODOTALobby) GetLeagueNonSelectionPriorityChoice() SelectionPriorityType { + if m != nil && m.LeagueNonSelectionPriorityChoice != nil { + return *m.LeagueNonSelectionPriorityChoice + } + return Default_CSODOTALobby_LeagueNonSelectionPriorityChoice +} + +func (m *CSODOTALobby) GetGameStartTime() uint32 { + if m != nil && m.GameStartTime != nil { + return *m.GameStartTime + } + return 0 +} + +func (m *CSODOTALobby) GetPauseSetting() LobbyDotaPauseSetting { + if m != nil && m.PauseSetting != nil { + return *m.PauseSetting + } + return Default_CSODOTALobby_PauseSetting +} + +type CSODOTALobby_CExtraMsg struct { + Id *uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"` + Contents []byte `protobuf:"bytes,2,opt,name=contents" json:"contents,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTALobby_CExtraMsg) Reset() { *m = CSODOTALobby_CExtraMsg{} } +func (m *CSODOTALobby_CExtraMsg) String() string { return proto.CompactTextString(m) } +func (*CSODOTALobby_CExtraMsg) ProtoMessage() {} +func (*CSODOTALobby_CExtraMsg) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{12, 0} } + +func (m *CSODOTALobby_CExtraMsg) GetId() uint32 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CSODOTALobby_CExtraMsg) GetContents() []byte { + if m != nil { + return m.Contents + } + return nil +} + +type CMsgLobbyEventPoints struct { + EventId *uint32 `protobuf:"varint,1,opt,name=event_id" json:"event_id,omitempty"` + AccountPoints []*CMsgLobbyEventPoints_AccountPoints `protobuf:"bytes,2,rep,name=account_points" json:"account_points,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLobbyEventPoints) Reset() { *m = CMsgLobbyEventPoints{} } +func (m *CMsgLobbyEventPoints) String() string { return proto.CompactTextString(m) } +func (*CMsgLobbyEventPoints) ProtoMessage() {} +func (*CMsgLobbyEventPoints) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{13} } + +func (m *CMsgLobbyEventPoints) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CMsgLobbyEventPoints) GetAccountPoints() []*CMsgLobbyEventPoints_AccountPoints { + if m != nil { + return m.AccountPoints + } + return nil +} + +type CMsgLobbyEventPoints_AccountPoints struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + NormalPoints *uint32 `protobuf:"varint,2,opt,name=normal_points" json:"normal_points,omitempty"` + PremiumPoints *uint32 `protobuf:"varint,3,opt,name=premium_points" json:"premium_points,omitempty"` + Owned *bool `protobuf:"varint,4,opt,name=owned" json:"owned,omitempty"` + FavoriteTeam *uint32 `protobuf:"varint,5,opt,name=favorite_team" json:"favorite_team,omitempty"` + FavoriteTeamLevel *uint32 `protobuf:"varint,6,opt,name=favorite_team_level" json:"favorite_team_level,omitempty"` + PointsHeld *uint32 `protobuf:"varint,7,opt,name=points_held" json:"points_held,omitempty"` + PremiumPointsHeld *uint32 `protobuf:"varint,8,opt,name=premium_points_held" json:"premium_points_held,omitempty"` + FavoriteTeamFoilLevel *uint32 `protobuf:"varint,9,opt,name=favorite_team_foil_level" json:"favorite_team_foil_level,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLobbyEventPoints_AccountPoints) Reset() { *m = CMsgLobbyEventPoints_AccountPoints{} } +func (m *CMsgLobbyEventPoints_AccountPoints) String() string { return proto.CompactTextString(m) } +func (*CMsgLobbyEventPoints_AccountPoints) ProtoMessage() {} +func (*CMsgLobbyEventPoints_AccountPoints) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{13, 0} +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetNormalPoints() uint32 { + if m != nil && m.NormalPoints != nil { + return *m.NormalPoints + } + return 0 +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetPremiumPoints() uint32 { + if m != nil && m.PremiumPoints != nil { + return *m.PremiumPoints + } + return 0 +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetOwned() bool { + if m != nil && m.Owned != nil { + return *m.Owned + } + return false +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetFavoriteTeam() uint32 { + if m != nil && m.FavoriteTeam != nil { + return *m.FavoriteTeam + } + return 0 +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetFavoriteTeamLevel() uint32 { + if m != nil && m.FavoriteTeamLevel != nil { + return *m.FavoriteTeamLevel + } + return 0 +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetPointsHeld() uint32 { + if m != nil && m.PointsHeld != nil { + return *m.PointsHeld + } + return 0 +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetPremiumPointsHeld() uint32 { + if m != nil && m.PremiumPointsHeld != nil { + return *m.PremiumPointsHeld + } + return 0 +} + +func (m *CMsgLobbyEventPoints_AccountPoints) GetFavoriteTeamFoilLevel() uint32 { + if m != nil && m.FavoriteTeamFoilLevel != nil { + return *m.FavoriteTeamFoilLevel + } + return 0 +} + +type CMsgDOTABroadcastNotification struct { + Message *string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTABroadcastNotification) Reset() { *m = CMsgDOTABroadcastNotification{} } +func (m *CMsgDOTABroadcastNotification) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTABroadcastNotification) ProtoMessage() {} +func (*CMsgDOTABroadcastNotification) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{14} } + +func (m *CMsgDOTABroadcastNotification) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +type CMsgDOTAPCBangTimedReward struct { + Persona *string `protobuf:"bytes,1,opt,name=persona" json:"persona,omitempty"` + Itemdef *uint32 `protobuf:"varint,2,opt,name=itemdef" json:"itemdef,omitempty"` + Pcbangname *string `protobuf:"bytes,3,opt,name=pcbangname" json:"pcbangname,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAPCBangTimedReward) Reset() { *m = CMsgDOTAPCBangTimedReward{} } +func (m *CMsgDOTAPCBangTimedReward) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAPCBangTimedReward) ProtoMessage() {} +func (*CMsgDOTAPCBangTimedReward) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{15} } + +func (m *CMsgDOTAPCBangTimedReward) GetPersona() string { + if m != nil && m.Persona != nil { + return *m.Persona + } + return "" +} + +func (m *CMsgDOTAPCBangTimedReward) GetItemdef() uint32 { + if m != nil && m.Itemdef != nil { + return *m.Itemdef + } + return 0 +} + +func (m *CMsgDOTAPCBangTimedReward) GetPcbangname() string { + if m != nil && m.Pcbangname != nil { + return *m.Pcbangname + } + return "" +} + +type CProtoItemHeroStatue struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + StatusEffectIndex *uint32 `protobuf:"varint,2,opt,name=status_effect_index" json:"status_effect_index,omitempty"` + SequenceName *string `protobuf:"bytes,3,opt,name=sequence_name" json:"sequence_name,omitempty"` + Cycle *float32 `protobuf:"fixed32,4,opt,name=cycle" json:"cycle,omitempty"` + Wearable []uint32 `protobuf:"varint,5,rep,name=wearable" json:"wearable,omitempty"` + Inscription *string `protobuf:"bytes,6,opt,name=inscription" json:"inscription,omitempty"` + Style []uint32 `protobuf:"varint,7,rep,name=style" json:"style,omitempty"` + TournamentDrop *bool `protobuf:"varint,8,opt,name=tournament_drop" json:"tournament_drop,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemHeroStatue) Reset() { *m = CProtoItemHeroStatue{} } +func (m *CProtoItemHeroStatue) String() string { return proto.CompactTextString(m) } +func (*CProtoItemHeroStatue) ProtoMessage() {} +func (*CProtoItemHeroStatue) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{16} } + +func (m *CProtoItemHeroStatue) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CProtoItemHeroStatue) GetStatusEffectIndex() uint32 { + if m != nil && m.StatusEffectIndex != nil { + return *m.StatusEffectIndex + } + return 0 +} + +func (m *CProtoItemHeroStatue) GetSequenceName() string { + if m != nil && m.SequenceName != nil { + return *m.SequenceName + } + return "" +} + +func (m *CProtoItemHeroStatue) GetCycle() float32 { + if m != nil && m.Cycle != nil { + return *m.Cycle + } + return 0 +} + +func (m *CProtoItemHeroStatue) GetWearable() []uint32 { + if m != nil { + return m.Wearable + } + return nil +} + +func (m *CProtoItemHeroStatue) GetInscription() string { + if m != nil && m.Inscription != nil { + return *m.Inscription + } + return "" +} + +func (m *CProtoItemHeroStatue) GetStyle() []uint32 { + if m != nil { + return m.Style + } + return nil +} + +func (m *CProtoItemHeroStatue) GetTournamentDrop() bool { + if m != nil && m.TournamentDrop != nil { + return *m.TournamentDrop + } + return false +} + +type CProtoItemTeamShowcase struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + StatusEffectIndex *uint32 `protobuf:"varint,2,opt,name=status_effect_index" json:"status_effect_index,omitempty"` + SequenceName *string `protobuf:"bytes,3,opt,name=sequence_name" json:"sequence_name,omitempty"` + Cycle *float32 `protobuf:"fixed32,4,opt,name=cycle" json:"cycle,omitempty"` + Wearable []uint32 `protobuf:"varint,5,rep,name=wearable" json:"wearable,omitempty"` + Inscription *string `protobuf:"bytes,6,opt,name=inscription" json:"inscription,omitempty"` + Style []uint32 `protobuf:"varint,7,rep,name=style" json:"style,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemTeamShowcase) Reset() { *m = CProtoItemTeamShowcase{} } +func (m *CProtoItemTeamShowcase) String() string { return proto.CompactTextString(m) } +func (*CProtoItemTeamShowcase) ProtoMessage() {} +func (*CProtoItemTeamShowcase) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{17} } + +func (m *CProtoItemTeamShowcase) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CProtoItemTeamShowcase) GetStatusEffectIndex() uint32 { + if m != nil && m.StatusEffectIndex != nil { + return *m.StatusEffectIndex + } + return 0 +} + +func (m *CProtoItemTeamShowcase) GetSequenceName() string { + if m != nil && m.SequenceName != nil { + return *m.SequenceName + } + return "" +} + +func (m *CProtoItemTeamShowcase) GetCycle() float32 { + if m != nil && m.Cycle != nil { + return *m.Cycle + } + return 0 +} + +func (m *CProtoItemTeamShowcase) GetWearable() []uint32 { + if m != nil { + return m.Wearable + } + return nil +} + +func (m *CProtoItemTeamShowcase) GetInscription() string { + if m != nil && m.Inscription != nil { + return *m.Inscription + } + return "" +} + +func (m *CProtoItemTeamShowcase) GetStyle() []uint32 { + if m != nil { + return m.Style + } + return nil +} + +type CMatchPlayerAbilityUpgrade struct { + Ability *uint32 `protobuf:"varint,1,opt,name=ability" json:"ability,omitempty"` + Time *uint32 `protobuf:"varint,2,opt,name=time" json:"time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMatchPlayerAbilityUpgrade) Reset() { *m = CMatchPlayerAbilityUpgrade{} } +func (m *CMatchPlayerAbilityUpgrade) String() string { return proto.CompactTextString(m) } +func (*CMatchPlayerAbilityUpgrade) ProtoMessage() {} +func (*CMatchPlayerAbilityUpgrade) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{18} } + +func (m *CMatchPlayerAbilityUpgrade) GetAbility() uint32 { + if m != nil && m.Ability != nil { + return *m.Ability + } + return 0 +} + +func (m *CMatchPlayerAbilityUpgrade) GetTime() uint32 { + if m != nil && m.Time != nil { + return *m.Time + } + return 0 +} + +type CMatchAdditionalUnitInventory struct { + UnitName *string `protobuf:"bytes,1,opt,name=unit_name" json:"unit_name,omitempty"` + Items []uint32 `protobuf:"varint,2,rep,name=items" json:"items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMatchAdditionalUnitInventory) Reset() { *m = CMatchAdditionalUnitInventory{} } +func (m *CMatchAdditionalUnitInventory) String() string { return proto.CompactTextString(m) } +func (*CMatchAdditionalUnitInventory) ProtoMessage() {} +func (*CMatchAdditionalUnitInventory) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{19} } + +func (m *CMatchAdditionalUnitInventory) GetUnitName() string { + if m != nil && m.UnitName != nil { + return *m.UnitName + } + return "" +} + +func (m *CMatchAdditionalUnitInventory) GetItems() []uint32 { + if m != nil { + return m.Items + } + return nil +} + +type CMatchHeroSelectEvent struct { + IsPick *bool `protobuf:"varint,1,opt,name=is_pick" json:"is_pick,omitempty"` + Team *uint32 `protobuf:"varint,2,opt,name=team" json:"team,omitempty"` + HeroId *uint32 `protobuf:"varint,3,opt,name=hero_id" json:"hero_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMatchHeroSelectEvent) Reset() { *m = CMatchHeroSelectEvent{} } +func (m *CMatchHeroSelectEvent) String() string { return proto.CompactTextString(m) } +func (*CMatchHeroSelectEvent) ProtoMessage() {} +func (*CMatchHeroSelectEvent) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{20} } + +func (m *CMatchHeroSelectEvent) GetIsPick() bool { + if m != nil && m.IsPick != nil { + return *m.IsPick + } + return false +} + +func (m *CMatchHeroSelectEvent) GetTeam() uint32 { + if m != nil && m.Team != nil { + return *m.Team + } + return 0 +} + +func (m *CMatchHeroSelectEvent) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +type CMsgDOTAProcessFantasyScheduledEvent struct { + Event *uint32 `protobuf:"varint,1,opt,name=event" json:"event,omitempty"` + Timestamp *uint32 `protobuf:"varint,2,opt,name=timestamp" json:"timestamp,omitempty"` + FantasyLeagueId *uint32 `protobuf:"varint,3,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + Season *uint32 `protobuf:"varint,4,opt,name=season" json:"season,omitempty"` + ReferenceData *uint32 `protobuf:"varint,5,opt,name=reference_data" json:"reference_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProcessFantasyScheduledEvent) Reset() { *m = CMsgDOTAProcessFantasyScheduledEvent{} } +func (m *CMsgDOTAProcessFantasyScheduledEvent) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProcessFantasyScheduledEvent) ProtoMessage() {} +func (*CMsgDOTAProcessFantasyScheduledEvent) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{21} +} + +func (m *CMsgDOTAProcessFantasyScheduledEvent) GetEvent() uint32 { + if m != nil && m.Event != nil { + return *m.Event + } + return 0 +} + +func (m *CMsgDOTAProcessFantasyScheduledEvent) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTAProcessFantasyScheduledEvent) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +func (m *CMsgDOTAProcessFantasyScheduledEvent) GetSeason() uint32 { + if m != nil && m.Season != nil { + return *m.Season + } + return 0 +} + +func (m *CMsgDOTAProcessFantasyScheduledEvent) GetReferenceData() uint32 { + if m != nil && m.ReferenceData != nil { + return *m.ReferenceData + } + return 0 +} + +type CMsgDOTAHasItemQuery struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHasItemQuery) Reset() { *m = CMsgDOTAHasItemQuery{} } +func (m *CMsgDOTAHasItemQuery) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHasItemQuery) ProtoMessage() {} +func (*CMsgDOTAHasItemQuery) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{22} } + +func (m *CMsgDOTAHasItemQuery) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAHasItemQuery) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgDOTAHasItemResponse struct { + HasItem *bool `protobuf:"varint,1,opt,name=has_item" json:"has_item,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHasItemResponse) Reset() { *m = CMsgDOTAHasItemResponse{} } +func (m *CMsgDOTAHasItemResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHasItemResponse) ProtoMessage() {} +func (*CMsgDOTAHasItemResponse) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{23} } + +func (m *CMsgDOTAHasItemResponse) GetHasItem() bool { + if m != nil && m.HasItem != nil { + return *m.HasItem + } + return false +} + +type CMsgDOTAHasItemDefsQuery struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ItemdefIds []uint32 `protobuf:"varint,2,rep,name=itemdef_ids" json:"itemdef_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHasItemDefsQuery) Reset() { *m = CMsgDOTAHasItemDefsQuery{} } +func (m *CMsgDOTAHasItemDefsQuery) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHasItemDefsQuery) ProtoMessage() {} +func (*CMsgDOTAHasItemDefsQuery) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{24} } + +func (m *CMsgDOTAHasItemDefsQuery) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAHasItemDefsQuery) GetItemdefIds() []uint32 { + if m != nil { + return m.ItemdefIds + } + return nil +} + +type CMsgDOTAHasItemDefsResponse struct { + HasItems *bool `protobuf:"varint,1,opt,name=has_items" json:"has_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAHasItemDefsResponse) Reset() { *m = CMsgDOTAHasItemDefsResponse{} } +func (m *CMsgDOTAHasItemDefsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAHasItemDefsResponse) ProtoMessage() {} +func (*CMsgDOTAHasItemDefsResponse) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{25} } + +func (m *CMsgDOTAHasItemDefsResponse) GetHasItems() bool { + if m != nil && m.HasItems != nil { + return *m.HasItems + } + return false +} + +type CMsgDOTAConsumeFantasyTicket struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + FantasyLeagueId *uint32 `protobuf:"varint,3,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAConsumeFantasyTicket) Reset() { *m = CMsgDOTAConsumeFantasyTicket{} } +func (m *CMsgDOTAConsumeFantasyTicket) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAConsumeFantasyTicket) ProtoMessage() {} +func (*CMsgDOTAConsumeFantasyTicket) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{26} } + +func (m *CMsgDOTAConsumeFantasyTicket) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAConsumeFantasyTicket) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgDOTAConsumeFantasyTicket) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgDOTAConsumeFantasyTicketFailure struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + FantasyLeagueId *uint32 `protobuf:"varint,3,opt,name=fantasy_league_id" json:"fantasy_league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAConsumeFantasyTicketFailure) Reset() { *m = CMsgDOTAConsumeFantasyTicketFailure{} } +func (m *CMsgDOTAConsumeFantasyTicketFailure) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAConsumeFantasyTicketFailure) ProtoMessage() {} +func (*CMsgDOTAConsumeFantasyTicketFailure) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{27} +} + +func (m *CMsgDOTAConsumeFantasyTicketFailure) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAConsumeFantasyTicketFailure) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgDOTAConsumeFantasyTicketFailure) GetFantasyLeagueId() uint32 { + if m != nil && m.FantasyLeagueId != nil { + return *m.FantasyLeagueId + } + return 0 +} + +type CMsgGCToGCFantasySetMatchLeague struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + LeagueId *uint32 `protobuf:"varint,2,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCFantasySetMatchLeague) Reset() { *m = CMsgGCToGCFantasySetMatchLeague{} } +func (m *CMsgGCToGCFantasySetMatchLeague) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCFantasySetMatchLeague) ProtoMessage() {} +func (*CMsgGCToGCFantasySetMatchLeague) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{28} +} + +func (m *CMsgGCToGCFantasySetMatchLeague) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgGCToGCFantasySetMatchLeague) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CSODOTAMapLocationState struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + LocationId *int32 `protobuf:"varint,2,opt,name=location_id" json:"location_id,omitempty"` + Completed *bool `protobuf:"varint,3,opt,name=completed" json:"completed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAMapLocationState) Reset() { *m = CSODOTAMapLocationState{} } +func (m *CSODOTAMapLocationState) String() string { return proto.CompactTextString(m) } +func (*CSODOTAMapLocationState) ProtoMessage() {} +func (*CSODOTAMapLocationState) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{29} } + +func (m *CSODOTAMapLocationState) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSODOTAMapLocationState) GetLocationId() int32 { + if m != nil && m.LocationId != nil { + return *m.LocationId + } + return 0 +} + +func (m *CSODOTAMapLocationState) GetCompleted() bool { + if m != nil && m.Completed != nil { + return *m.Completed + } + return false +} + +type CMsgNexonPartnerUpdate struct { + Messagetype *uint32 `protobuf:"varint,1,opt,name=messagetype" json:"messagetype,omitempty"` + Timeremaining *uint32 `protobuf:"varint,2,opt,name=timeremaining" json:"timeremaining,omitempty"` + Terminate *bool `protobuf:"varint,3,opt,name=terminate" json:"terminate,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgNexonPartnerUpdate) Reset() { *m = CMsgNexonPartnerUpdate{} } +func (m *CMsgNexonPartnerUpdate) String() string { return proto.CompactTextString(m) } +func (*CMsgNexonPartnerUpdate) ProtoMessage() {} +func (*CMsgNexonPartnerUpdate) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{30} } + +func (m *CMsgNexonPartnerUpdate) GetMessagetype() uint32 { + if m != nil && m.Messagetype != nil { + return *m.Messagetype + } + return 0 +} + +func (m *CMsgNexonPartnerUpdate) GetTimeremaining() uint32 { + if m != nil && m.Timeremaining != nil { + return *m.Timeremaining + } + return 0 +} + +func (m *CMsgNexonPartnerUpdate) GetTerminate() bool { + if m != nil && m.Terminate != nil { + return *m.Terminate + } + return false +} + +type CMsgMakeOffering struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgMakeOffering) Reset() { *m = CMsgMakeOffering{} } +func (m *CMsgMakeOffering) String() string { return proto.CompactTextString(m) } +func (*CMsgMakeOffering) ProtoMessage() {} +func (*CMsgMakeOffering) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{31} } + +func (m *CMsgMakeOffering) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgRequestOfferings struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestOfferings) Reset() { *m = CMsgRequestOfferings{} } +func (m *CMsgRequestOfferings) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestOfferings) ProtoMessage() {} +func (*CMsgRequestOfferings) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{32} } + +type CMsgRequestOfferingsResponse struct { + Offerings []*CMsgRequestOfferingsResponse_NewYearsOffering `protobuf:"bytes,1,rep,name=offerings" json:"offerings,omitempty"` + Completed *bool `protobuf:"varint,2,opt,name=completed" json:"completed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestOfferingsResponse) Reset() { *m = CMsgRequestOfferingsResponse{} } +func (m *CMsgRequestOfferingsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestOfferingsResponse) ProtoMessage() {} +func (*CMsgRequestOfferingsResponse) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{33} } + +func (m *CMsgRequestOfferingsResponse) GetOfferings() []*CMsgRequestOfferingsResponse_NewYearsOffering { + if m != nil { + return m.Offerings + } + return nil +} + +func (m *CMsgRequestOfferingsResponse) GetCompleted() bool { + if m != nil && m.Completed != nil { + return *m.Completed + } + return false +} + +type CMsgRequestOfferingsResponse_NewYearsOffering struct { + DefIndex *uint32 `protobuf:"varint,1,opt,name=def_index" json:"def_index,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestOfferingsResponse_NewYearsOffering) Reset() { + *m = CMsgRequestOfferingsResponse_NewYearsOffering{} +} +func (m *CMsgRequestOfferingsResponse_NewYearsOffering) String() string { + return proto.CompactTextString(m) +} +func (*CMsgRequestOfferingsResponse_NewYearsOffering) ProtoMessage() {} +func (*CMsgRequestOfferingsResponse_NewYearsOffering) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{33, 0} +} + +func (m *CMsgRequestOfferingsResponse_NewYearsOffering) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +func (m *CMsgRequestOfferingsResponse_NewYearsOffering) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgLeagueAdminList struct { + AccountIds []uint32 `protobuf:"varint,1,rep,name=account_ids" json:"account_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLeagueAdminList) Reset() { *m = CMsgLeagueAdminList{} } +func (m *CMsgLeagueAdminList) String() string { return proto.CompactTextString(m) } +func (*CMsgLeagueAdminList) ProtoMessage() {} +func (*CMsgLeagueAdminList) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{34} } + +func (m *CMsgLeagueAdminList) GetAccountIds() []uint32 { + if m != nil { + return m.AccountIds + } + return nil +} + +type CMsgPerfectWorldUserLookupRequest struct { + UserName *string `protobuf:"bytes,1,opt,name=user_name" json:"user_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPerfectWorldUserLookupRequest) Reset() { *m = CMsgPerfectWorldUserLookupRequest{} } +func (m *CMsgPerfectWorldUserLookupRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgPerfectWorldUserLookupRequest) ProtoMessage() {} +func (*CMsgPerfectWorldUserLookupRequest) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{35} +} + +func (m *CMsgPerfectWorldUserLookupRequest) GetUserName() string { + if m != nil && m.UserName != nil { + return *m.UserName + } + return "" +} + +type CMsgPerfectWorldUserLookupResponse struct { + ResultCode *CMsgPerfectWorldUserLookupResponse_EResultCode `protobuf:"varint,1,opt,name=result_code,enum=CMsgPerfectWorldUserLookupResponse_EResultCode,def=0" json:"result_code,omitempty"` + AccountId *uint32 `protobuf:"varint,2,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPerfectWorldUserLookupResponse) Reset() { *m = CMsgPerfectWorldUserLookupResponse{} } +func (m *CMsgPerfectWorldUserLookupResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgPerfectWorldUserLookupResponse) ProtoMessage() {} +func (*CMsgPerfectWorldUserLookupResponse) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{36} +} + +const Default_CMsgPerfectWorldUserLookupResponse_ResultCode CMsgPerfectWorldUserLookupResponse_EResultCode = CMsgPerfectWorldUserLookupResponse_SUCCESS_ACCOUNT_FOUND + +func (m *CMsgPerfectWorldUserLookupResponse) GetResultCode() CMsgPerfectWorldUserLookupResponse_EResultCode { + if m != nil && m.ResultCode != nil { + return *m.ResultCode + } + return Default_CMsgPerfectWorldUserLookupResponse_ResultCode +} + +func (m *CMsgPerfectWorldUserLookupResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CCompendiumTimestampedData struct { + GameTime *uint32 `protobuf:"varint,1,opt,name=game_time" json:"game_time,omitempty"` + Gpm *uint32 `protobuf:"varint,2,opt,name=gpm" json:"gpm,omitempty"` + Xpm *uint32 `protobuf:"varint,3,opt,name=xpm" json:"xpm,omitempty"` + Kills *uint32 `protobuf:"varint,4,opt,name=kills" json:"kills,omitempty"` + Deaths *uint32 `protobuf:"varint,5,opt,name=deaths" json:"deaths,omitempty"` + ItemPurchases []uint32 `protobuf:"varint,6,rep,name=item_purchases" json:"item_purchases,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCompendiumTimestampedData) Reset() { *m = CCompendiumTimestampedData{} } +func (m *CCompendiumTimestampedData) String() string { return proto.CompactTextString(m) } +func (*CCompendiumTimestampedData) ProtoMessage() {} +func (*CCompendiumTimestampedData) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{37} } + +func (m *CCompendiumTimestampedData) GetGameTime() uint32 { + if m != nil && m.GameTime != nil { + return *m.GameTime + } + return 0 +} + +func (m *CCompendiumTimestampedData) GetGpm() uint32 { + if m != nil && m.Gpm != nil { + return *m.Gpm + } + return 0 +} + +func (m *CCompendiumTimestampedData) GetXpm() uint32 { + if m != nil && m.Xpm != nil { + return *m.Xpm + } + return 0 +} + +func (m *CCompendiumTimestampedData) GetKills() uint32 { + if m != nil && m.Kills != nil { + return *m.Kills + } + return 0 +} + +func (m *CCompendiumTimestampedData) GetDeaths() uint32 { + if m != nil && m.Deaths != nil { + return *m.Deaths + } + return 0 +} + +func (m *CCompendiumTimestampedData) GetItemPurchases() []uint32 { + if m != nil { + return m.ItemPurchases + } + return nil +} + +type CCompendiumGameTimeline struct { + Data []*CCompendiumTimestampedData `protobuf:"bytes,1,rep,name=data" json:"data,omitempty"` + Tags []string `protobuf:"bytes,2,rep,name=tags" json:"tags,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCompendiumGameTimeline) Reset() { *m = CCompendiumGameTimeline{} } +func (m *CCompendiumGameTimeline) String() string { return proto.CompactTextString(m) } +func (*CCompendiumGameTimeline) ProtoMessage() {} +func (*CCompendiumGameTimeline) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{38} } + +func (m *CCompendiumGameTimeline) GetData() []*CCompendiumTimestampedData { + if m != nil { + return m.Data + } + return nil +} + +func (m *CCompendiumGameTimeline) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +type CCompendiumGameList struct { + Games []*CCompendiumGameTimeline `protobuf:"bytes,1,rep,name=games" json:"games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCompendiumGameList) Reset() { *m = CCompendiumGameList{} } +func (m *CCompendiumGameList) String() string { return proto.CompactTextString(m) } +func (*CCompendiumGameList) ProtoMessage() {} +func (*CCompendiumGameList) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{39} } + +func (m *CCompendiumGameList) GetGames() []*CCompendiumGameTimeline { + if m != nil { + return m.Games + } + return nil +} + +type CAdditionalEquipSlot struct { + ClassId *uint32 `protobuf:"varint,1,opt,name=class_id" json:"class_id,omitempty"` + SlotId *uint32 `protobuf:"varint,2,opt,name=slot_id" json:"slot_id,omitempty"` + DefIndex *uint32 `protobuf:"varint,3,opt,name=def_index" json:"def_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CAdditionalEquipSlot) Reset() { *m = CAdditionalEquipSlot{} } +func (m *CAdditionalEquipSlot) String() string { return proto.CompactTextString(m) } +func (*CAdditionalEquipSlot) ProtoMessage() {} +func (*CAdditionalEquipSlot) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{40} } + +func (m *CAdditionalEquipSlot) GetClassId() uint32 { + if m != nil && m.ClassId != nil { + return *m.ClassId + } + return 0 +} + +func (m *CAdditionalEquipSlot) GetSlotId() uint32 { + if m != nil && m.SlotId != nil { + return *m.SlotId + } + return 0 +} + +func (m *CAdditionalEquipSlot) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +type CMsgDOTARedeemItem struct { + CurrencyId *uint64 `protobuf:"varint,1,opt,name=currency_id" json:"currency_id,omitempty"` + PurchaseDef *uint32 `protobuf:"varint,2,opt,name=purchase_def" json:"purchase_def,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARedeemItem) Reset() { *m = CMsgDOTARedeemItem{} } +func (m *CMsgDOTARedeemItem) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARedeemItem) ProtoMessage() {} +func (*CMsgDOTARedeemItem) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{41} } + +func (m *CMsgDOTARedeemItem) GetCurrencyId() uint64 { + if m != nil && m.CurrencyId != nil { + return *m.CurrencyId + } + return 0 +} + +func (m *CMsgDOTARedeemItem) GetPurchaseDef() uint32 { + if m != nil && m.PurchaseDef != nil { + return *m.PurchaseDef + } + return 0 +} + +type CMsgDOTARedeemItemResponse struct { + Response *CMsgDOTARedeemItemResponse_EResultCode `protobuf:"varint,1,opt,name=response,enum=CMsgDOTARedeemItemResponse_EResultCode,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARedeemItemResponse) Reset() { *m = CMsgDOTARedeemItemResponse{} } +func (m *CMsgDOTARedeemItemResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARedeemItemResponse) ProtoMessage() {} +func (*CMsgDOTARedeemItemResponse) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{42} } + +const Default_CMsgDOTARedeemItemResponse_Response CMsgDOTARedeemItemResponse_EResultCode = CMsgDOTARedeemItemResponse_k_Succeeded + +func (m *CMsgDOTARedeemItemResponse) GetResponse() CMsgDOTARedeemItemResponse_EResultCode { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgDOTARedeemItemResponse_Response +} + +type CMsgDOTACombatLogEntry struct { + Type *DOTA_COMBATLOG_TYPES `protobuf:"varint,1,opt,name=type,enum=DOTA_COMBATLOG_TYPES,def=0" json:"type,omitempty"` + TargetName *uint32 `protobuf:"varint,2,opt,name=target_name" json:"target_name,omitempty"` + TargetSourceName *uint32 `protobuf:"varint,3,opt,name=target_source_name" json:"target_source_name,omitempty"` + AttackerName *uint32 `protobuf:"varint,4,opt,name=attacker_name" json:"attacker_name,omitempty"` + DamageSourceName *uint32 `protobuf:"varint,5,opt,name=damage_source_name" json:"damage_source_name,omitempty"` + InflictorName *uint32 `protobuf:"varint,6,opt,name=inflictor_name" json:"inflictor_name,omitempty"` + IsAttackerIllusion *bool `protobuf:"varint,7,opt,name=is_attacker_illusion" json:"is_attacker_illusion,omitempty"` + IsAttackerHero *bool `protobuf:"varint,8,opt,name=is_attacker_hero" json:"is_attacker_hero,omitempty"` + IsTargetIllusion *bool `protobuf:"varint,9,opt,name=is_target_illusion" json:"is_target_illusion,omitempty"` + IsTargetHero *bool `protobuf:"varint,10,opt,name=is_target_hero" json:"is_target_hero,omitempty"` + IsVisibleRadiant *bool `protobuf:"varint,11,opt,name=is_visible_radiant" json:"is_visible_radiant,omitempty"` + IsVisibleDire *bool `protobuf:"varint,12,opt,name=is_visible_dire" json:"is_visible_dire,omitempty"` + Value *uint32 `protobuf:"varint,13,opt,name=value" json:"value,omitempty"` + Health *int32 `protobuf:"varint,14,opt,name=health" json:"health,omitempty"` + Timestamp *float32 `protobuf:"fixed32,15,opt,name=timestamp" json:"timestamp,omitempty"` + StunDuration *float32 `protobuf:"fixed32,16,opt,name=stun_duration" json:"stun_duration,omitempty"` + SlowDuration *float32 `protobuf:"fixed32,17,opt,name=slow_duration" json:"slow_duration,omitempty"` + IsAbilityToggleOn *bool `protobuf:"varint,18,opt,name=is_ability_toggle_on" json:"is_ability_toggle_on,omitempty"` + IsAbilityToggleOff *bool `protobuf:"varint,19,opt,name=is_ability_toggle_off" json:"is_ability_toggle_off,omitempty"` + AbilityLevel *uint32 `protobuf:"varint,20,opt,name=ability_level" json:"ability_level,omitempty"` + LocationX *float32 `protobuf:"fixed32,21,opt,name=location_x" json:"location_x,omitempty"` + LocationY *float32 `protobuf:"fixed32,22,opt,name=location_y" json:"location_y,omitempty"` + GoldReason *uint32 `protobuf:"varint,23,opt,name=gold_reason" json:"gold_reason,omitempty"` + TimestampRaw *float32 `protobuf:"fixed32,24,opt,name=timestamp_raw" json:"timestamp_raw,omitempty"` + ModifierDuration *float32 `protobuf:"fixed32,25,opt,name=modifier_duration" json:"modifier_duration,omitempty"` + XpReason *uint32 `protobuf:"varint,26,opt,name=xp_reason" json:"xp_reason,omitempty"` + LastHits *uint32 `protobuf:"varint,27,opt,name=last_hits" json:"last_hits,omitempty"` + AttackerTeam *uint32 `protobuf:"varint,28,opt,name=attacker_team" json:"attacker_team,omitempty"` + TargetTeam *uint32 `protobuf:"varint,29,opt,name=target_team" json:"target_team,omitempty"` + ObsWardsPlaced *uint32 `protobuf:"varint,30,opt,name=obs_wards_placed" json:"obs_wards_placed,omitempty"` + AssistPlayer0 *uint32 `protobuf:"varint,31,opt,name=assist_player0" json:"assist_player0,omitempty"` + AssistPlayer1 *uint32 `protobuf:"varint,32,opt,name=assist_player1" json:"assist_player1,omitempty"` + AssistPlayer2 *uint32 `protobuf:"varint,33,opt,name=assist_player2" json:"assist_player2,omitempty"` + AssistPlayer3 *uint32 `protobuf:"varint,34,opt,name=assist_player3" json:"assist_player3,omitempty"` + StackCount *uint32 `protobuf:"varint,35,opt,name=stack_count" json:"stack_count,omitempty"` + HiddenModifier *bool `protobuf:"varint,36,opt,name=hidden_modifier" json:"hidden_modifier,omitempty"` + IsTargetBuilding *bool `protobuf:"varint,37,opt,name=is_target_building" json:"is_target_building,omitempty"` + NeutralCampType *uint32 `protobuf:"varint,38,opt,name=neutral_camp_type" json:"neutral_camp_type,omitempty"` + RuneType *uint32 `protobuf:"varint,39,opt,name=rune_type" json:"rune_type,omitempty"` + AssistPlayers []uint32 `protobuf:"varint,40,rep,name=assist_players" json:"assist_players,omitempty"` + IsHealSave *bool `protobuf:"varint,41,opt,name=is_heal_save" json:"is_heal_save,omitempty"` + IsUltimateAbility *bool `protobuf:"varint,42,opt,name=is_ultimate_ability" json:"is_ultimate_ability,omitempty"` + AttackerHeroLevel *uint32 `protobuf:"varint,43,opt,name=attacker_hero_level" json:"attacker_hero_level,omitempty"` + TargetHeroLevel *uint32 `protobuf:"varint,44,opt,name=target_hero_level" json:"target_hero_level,omitempty"` + Xpm *uint32 `protobuf:"varint,45,opt,name=xpm" json:"xpm,omitempty"` + Gpm *uint32 `protobuf:"varint,46,opt,name=gpm" json:"gpm,omitempty"` + EventLocation *uint32 `protobuf:"varint,47,opt,name=event_location" json:"event_location,omitempty"` + TargetIsSelf *bool `protobuf:"varint,48,opt,name=target_is_self" json:"target_is_self,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTACombatLogEntry) Reset() { *m = CMsgDOTACombatLogEntry{} } +func (m *CMsgDOTACombatLogEntry) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTACombatLogEntry) ProtoMessage() {} +func (*CMsgDOTACombatLogEntry) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{43} } + +const Default_CMsgDOTACombatLogEntry_Type DOTA_COMBATLOG_TYPES = DOTA_COMBATLOG_TYPES_DOTA_COMBATLOG_DAMAGE + +func (m *CMsgDOTACombatLogEntry) GetType() DOTA_COMBATLOG_TYPES { + if m != nil && m.Type != nil { + return *m.Type + } + return Default_CMsgDOTACombatLogEntry_Type +} + +func (m *CMsgDOTACombatLogEntry) GetTargetName() uint32 { + if m != nil && m.TargetName != nil { + return *m.TargetName + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetTargetSourceName() uint32 { + if m != nil && m.TargetSourceName != nil { + return *m.TargetSourceName + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetAttackerName() uint32 { + if m != nil && m.AttackerName != nil { + return *m.AttackerName + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetDamageSourceName() uint32 { + if m != nil && m.DamageSourceName != nil { + return *m.DamageSourceName + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetInflictorName() uint32 { + if m != nil && m.InflictorName != nil { + return *m.InflictorName + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetIsAttackerIllusion() bool { + if m != nil && m.IsAttackerIllusion != nil { + return *m.IsAttackerIllusion + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsAttackerHero() bool { + if m != nil && m.IsAttackerHero != nil { + return *m.IsAttackerHero + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsTargetIllusion() bool { + if m != nil && m.IsTargetIllusion != nil { + return *m.IsTargetIllusion + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsTargetHero() bool { + if m != nil && m.IsTargetHero != nil { + return *m.IsTargetHero + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsVisibleRadiant() bool { + if m != nil && m.IsVisibleRadiant != nil { + return *m.IsVisibleRadiant + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsVisibleDire() bool { + if m != nil && m.IsVisibleDire != nil { + return *m.IsVisibleDire + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetValue() uint32 { + if m != nil && m.Value != nil { + return *m.Value + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetHealth() int32 { + if m != nil && m.Health != nil { + return *m.Health + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetTimestamp() float32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetStunDuration() float32 { + if m != nil && m.StunDuration != nil { + return *m.StunDuration + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetSlowDuration() float32 { + if m != nil && m.SlowDuration != nil { + return *m.SlowDuration + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetIsAbilityToggleOn() bool { + if m != nil && m.IsAbilityToggleOn != nil { + return *m.IsAbilityToggleOn + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsAbilityToggleOff() bool { + if m != nil && m.IsAbilityToggleOff != nil { + return *m.IsAbilityToggleOff + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetAbilityLevel() uint32 { + if m != nil && m.AbilityLevel != nil { + return *m.AbilityLevel + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetLocationX() float32 { + if m != nil && m.LocationX != nil { + return *m.LocationX + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetLocationY() float32 { + if m != nil && m.LocationY != nil { + return *m.LocationY + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetGoldReason() uint32 { + if m != nil && m.GoldReason != nil { + return *m.GoldReason + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetTimestampRaw() float32 { + if m != nil && m.TimestampRaw != nil { + return *m.TimestampRaw + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetModifierDuration() float32 { + if m != nil && m.ModifierDuration != nil { + return *m.ModifierDuration + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetXpReason() uint32 { + if m != nil && m.XpReason != nil { + return *m.XpReason + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetLastHits() uint32 { + if m != nil && m.LastHits != nil { + return *m.LastHits + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetAttackerTeam() uint32 { + if m != nil && m.AttackerTeam != nil { + return *m.AttackerTeam + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetTargetTeam() uint32 { + if m != nil && m.TargetTeam != nil { + return *m.TargetTeam + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetObsWardsPlaced() uint32 { + if m != nil && m.ObsWardsPlaced != nil { + return *m.ObsWardsPlaced + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetAssistPlayer0() uint32 { + if m != nil && m.AssistPlayer0 != nil { + return *m.AssistPlayer0 + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetAssistPlayer1() uint32 { + if m != nil && m.AssistPlayer1 != nil { + return *m.AssistPlayer1 + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetAssistPlayer2() uint32 { + if m != nil && m.AssistPlayer2 != nil { + return *m.AssistPlayer2 + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetAssistPlayer3() uint32 { + if m != nil && m.AssistPlayer3 != nil { + return *m.AssistPlayer3 + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetStackCount() uint32 { + if m != nil && m.StackCount != nil { + return *m.StackCount + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetHiddenModifier() bool { + if m != nil && m.HiddenModifier != nil { + return *m.HiddenModifier + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsTargetBuilding() bool { + if m != nil && m.IsTargetBuilding != nil { + return *m.IsTargetBuilding + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetNeutralCampType() uint32 { + if m != nil && m.NeutralCampType != nil { + return *m.NeutralCampType + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetRuneType() uint32 { + if m != nil && m.RuneType != nil { + return *m.RuneType + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetAssistPlayers() []uint32 { + if m != nil { + return m.AssistPlayers + } + return nil +} + +func (m *CMsgDOTACombatLogEntry) GetIsHealSave() bool { + if m != nil && m.IsHealSave != nil { + return *m.IsHealSave + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetIsUltimateAbility() bool { + if m != nil && m.IsUltimateAbility != nil { + return *m.IsUltimateAbility + } + return false +} + +func (m *CMsgDOTACombatLogEntry) GetAttackerHeroLevel() uint32 { + if m != nil && m.AttackerHeroLevel != nil { + return *m.AttackerHeroLevel + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetTargetHeroLevel() uint32 { + if m != nil && m.TargetHeroLevel != nil { + return *m.TargetHeroLevel + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetXpm() uint32 { + if m != nil && m.Xpm != nil { + return *m.Xpm + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetGpm() uint32 { + if m != nil && m.Gpm != nil { + return *m.Gpm + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetEventLocation() uint32 { + if m != nil && m.EventLocation != nil { + return *m.EventLocation + } + return 0 +} + +func (m *CMsgDOTACombatLogEntry) GetTargetIsSelf() bool { + if m != nil && m.TargetIsSelf != nil { + return *m.TargetIsSelf + } + return false +} + +type CMsgDOTAProfileCard struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + BackgroundDefIndex *uint32 `protobuf:"varint,2,opt,name=background_def_index" json:"background_def_index,omitempty"` + Slots []*CMsgDOTAProfileCard_Slot `protobuf:"bytes,3,rep,name=slots" json:"slots,omitempty"` + BadgePoints *uint32 `protobuf:"varint,4,opt,name=badge_points" json:"badge_points,omitempty"` + EventPoints *uint32 `protobuf:"varint,5,opt,name=event_points" json:"event_points,omitempty"` + EventId *uint32 `protobuf:"varint,6,opt,name=event_id" json:"event_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileCard) Reset() { *m = CMsgDOTAProfileCard{} } +func (m *CMsgDOTAProfileCard) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileCard) ProtoMessage() {} +func (*CMsgDOTAProfileCard) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{44} } + +func (m *CMsgDOTAProfileCard) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgDOTAProfileCard) GetBackgroundDefIndex() uint32 { + if m != nil && m.BackgroundDefIndex != nil { + return *m.BackgroundDefIndex + } + return 0 +} + +func (m *CMsgDOTAProfileCard) GetSlots() []*CMsgDOTAProfileCard_Slot { + if m != nil { + return m.Slots + } + return nil +} + +func (m *CMsgDOTAProfileCard) GetBadgePoints() uint32 { + if m != nil && m.BadgePoints != nil { + return *m.BadgePoints + } + return 0 +} + +func (m *CMsgDOTAProfileCard) GetEventPoints() uint32 { + if m != nil && m.EventPoints != nil { + return *m.EventPoints + } + return 0 +} + +func (m *CMsgDOTAProfileCard) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +type CMsgDOTAProfileCard_Slot struct { + SlotId *uint32 `protobuf:"varint,1,opt,name=slot_id" json:"slot_id,omitempty"` + Trophy *CMsgDOTAProfileCard_Slot_Trophy `protobuf:"bytes,2,opt,name=trophy" json:"trophy,omitempty"` + Stat *CMsgDOTAProfileCard_Slot_Stat `protobuf:"bytes,3,opt,name=stat" json:"stat,omitempty"` + Item *CMsgDOTAProfileCard_Slot_Item `protobuf:"bytes,4,opt,name=item" json:"item,omitempty"` + Hero *CMsgDOTAProfileCard_Slot_Hero `protobuf:"bytes,5,opt,name=hero" json:"hero,omitempty"` + Emoticon *CMsgDOTAProfileCard_Slot_Emoticon `protobuf:"bytes,6,opt,name=emoticon" json:"emoticon,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileCard_Slot) Reset() { *m = CMsgDOTAProfileCard_Slot{} } +func (m *CMsgDOTAProfileCard_Slot) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileCard_Slot) ProtoMessage() {} +func (*CMsgDOTAProfileCard_Slot) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{44, 0} } + +func (m *CMsgDOTAProfileCard_Slot) GetSlotId() uint32 { + if m != nil && m.SlotId != nil { + return *m.SlotId + } + return 0 +} + +func (m *CMsgDOTAProfileCard_Slot) GetTrophy() *CMsgDOTAProfileCard_Slot_Trophy { + if m != nil { + return m.Trophy + } + return nil +} + +func (m *CMsgDOTAProfileCard_Slot) GetStat() *CMsgDOTAProfileCard_Slot_Stat { + if m != nil { + return m.Stat + } + return nil +} + +func (m *CMsgDOTAProfileCard_Slot) GetItem() *CMsgDOTAProfileCard_Slot_Item { + if m != nil { + return m.Item + } + return nil +} + +func (m *CMsgDOTAProfileCard_Slot) GetHero() *CMsgDOTAProfileCard_Slot_Hero { + if m != nil { + return m.Hero + } + return nil +} + +func (m *CMsgDOTAProfileCard_Slot) GetEmoticon() *CMsgDOTAProfileCard_Slot_Emoticon { + if m != nil { + return m.Emoticon + } + return nil +} + +type CMsgDOTAProfileCard_Slot_Trophy struct { + TrophyId *uint32 `protobuf:"varint,1,opt,name=trophy_id" json:"trophy_id,omitempty"` + TrophyScore *uint32 `protobuf:"varint,2,opt,name=trophy_score" json:"trophy_score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileCard_Slot_Trophy) Reset() { *m = CMsgDOTAProfileCard_Slot_Trophy{} } +func (m *CMsgDOTAProfileCard_Slot_Trophy) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileCard_Slot_Trophy) ProtoMessage() {} +func (*CMsgDOTAProfileCard_Slot_Trophy) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{44, 0, 0} +} + +func (m *CMsgDOTAProfileCard_Slot_Trophy) GetTrophyId() uint32 { + if m != nil && m.TrophyId != nil { + return *m.TrophyId + } + return 0 +} + +func (m *CMsgDOTAProfileCard_Slot_Trophy) GetTrophyScore() uint32 { + if m != nil && m.TrophyScore != nil { + return *m.TrophyScore + } + return 0 +} + +type CMsgDOTAProfileCard_Slot_Stat struct { + StatId *CMsgDOTAProfileCard_EStatID `protobuf:"varint,1,opt,name=stat_id,enum=CMsgDOTAProfileCard_EStatID,def=1" json:"stat_id,omitempty"` + StatScore *uint32 `protobuf:"varint,2,opt,name=stat_score" json:"stat_score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileCard_Slot_Stat) Reset() { *m = CMsgDOTAProfileCard_Slot_Stat{} } +func (m *CMsgDOTAProfileCard_Slot_Stat) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileCard_Slot_Stat) ProtoMessage() {} +func (*CMsgDOTAProfileCard_Slot_Stat) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{44, 0, 1} +} + +const Default_CMsgDOTAProfileCard_Slot_Stat_StatId CMsgDOTAProfileCard_EStatID = CMsgDOTAProfileCard_k_eStat_SoloRank + +func (m *CMsgDOTAProfileCard_Slot_Stat) GetStatId() CMsgDOTAProfileCard_EStatID { + if m != nil && m.StatId != nil { + return *m.StatId + } + return Default_CMsgDOTAProfileCard_Slot_Stat_StatId +} + +func (m *CMsgDOTAProfileCard_Slot_Stat) GetStatScore() uint32 { + if m != nil && m.StatScore != nil { + return *m.StatScore + } + return 0 +} + +type CMsgDOTAProfileCard_Slot_Item struct { + SerializedItem []byte `protobuf:"bytes,1,opt,name=serialized_item" json:"serialized_item,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileCard_Slot_Item) Reset() { *m = CMsgDOTAProfileCard_Slot_Item{} } +func (m *CMsgDOTAProfileCard_Slot_Item) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileCard_Slot_Item) ProtoMessage() {} +func (*CMsgDOTAProfileCard_Slot_Item) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{44, 0, 2} +} + +func (m *CMsgDOTAProfileCard_Slot_Item) GetSerializedItem() []byte { + if m != nil { + return m.SerializedItem + } + return nil +} + +func (m *CMsgDOTAProfileCard_Slot_Item) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgDOTAProfileCard_Slot_Hero struct { + HeroId *uint32 `protobuf:"varint,1,opt,name=hero_id" json:"hero_id,omitempty"` + HeroWins *uint32 `protobuf:"varint,2,opt,name=hero_wins" json:"hero_wins,omitempty"` + HeroLosses *uint32 `protobuf:"varint,3,opt,name=hero_losses" json:"hero_losses,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileCard_Slot_Hero) Reset() { *m = CMsgDOTAProfileCard_Slot_Hero{} } +func (m *CMsgDOTAProfileCard_Slot_Hero) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileCard_Slot_Hero) ProtoMessage() {} +func (*CMsgDOTAProfileCard_Slot_Hero) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{44, 0, 3} +} + +func (m *CMsgDOTAProfileCard_Slot_Hero) GetHeroId() uint32 { + if m != nil && m.HeroId != nil { + return *m.HeroId + } + return 0 +} + +func (m *CMsgDOTAProfileCard_Slot_Hero) GetHeroWins() uint32 { + if m != nil && m.HeroWins != nil { + return *m.HeroWins + } + return 0 +} + +func (m *CMsgDOTAProfileCard_Slot_Hero) GetHeroLosses() uint32 { + if m != nil && m.HeroLosses != nil { + return *m.HeroLosses + } + return 0 +} + +type CMsgDOTAProfileCard_Slot_Emoticon struct { + EmoticonId *uint32 `protobuf:"varint,1,opt,name=emoticon_id" json:"emoticon_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTAProfileCard_Slot_Emoticon) Reset() { *m = CMsgDOTAProfileCard_Slot_Emoticon{} } +func (m *CMsgDOTAProfileCard_Slot_Emoticon) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTAProfileCard_Slot_Emoticon) ProtoMessage() {} +func (*CMsgDOTAProfileCard_Slot_Emoticon) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{44, 0, 4} +} + +func (m *CMsgDOTAProfileCard_Slot_Emoticon) GetEmoticonId() uint32 { + if m != nil && m.EmoticonId != nil { + return *m.EmoticonId + } + return 0 +} + +type CMsgGCToClientNewBloomTimingUpdated struct { + IsActive *bool `protobuf:"varint,1,opt,name=is_active" json:"is_active,omitempty"` + NextTransitionTime *uint32 `protobuf:"varint,2,opt,name=next_transition_time" json:"next_transition_time,omitempty"` + BonusAmount *uint32 `protobuf:"varint,3,opt,name=bonus_amount" json:"bonus_amount,omitempty"` + StandbyDuration *uint32 `protobuf:"varint,4,opt,name=standby_duration" json:"standby_duration,omitempty"` + TransitionTime *uint32 `protobuf:"varint,5,opt,name=transition_time" json:"transition_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientNewBloomTimingUpdated) Reset() { *m = CMsgGCToClientNewBloomTimingUpdated{} } +func (m *CMsgGCToClientNewBloomTimingUpdated) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientNewBloomTimingUpdated) ProtoMessage() {} +func (*CMsgGCToClientNewBloomTimingUpdated) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{45} +} + +func (m *CMsgGCToClientNewBloomTimingUpdated) GetIsActive() bool { + if m != nil && m.IsActive != nil { + return *m.IsActive + } + return false +} + +func (m *CMsgGCToClientNewBloomTimingUpdated) GetNextTransitionTime() uint32 { + if m != nil && m.NextTransitionTime != nil { + return *m.NextTransitionTime + } + return 0 +} + +func (m *CMsgGCToClientNewBloomTimingUpdated) GetBonusAmount() uint32 { + if m != nil && m.BonusAmount != nil { + return *m.BonusAmount + } + return 0 +} + +func (m *CMsgGCToClientNewBloomTimingUpdated) GetStandbyDuration() uint32 { + if m != nil && m.StandbyDuration != nil { + return *m.StandbyDuration + } + return 0 +} + +func (m *CMsgGCToClientNewBloomTimingUpdated) GetTransitionTime() uint32 { + if m != nil && m.TransitionTime != nil { + return *m.TransitionTime + } + return 0 +} + +type CSODOTAPlayerChallenge struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + EventId *uint32 `protobuf:"varint,2,opt,name=event_id" json:"event_id,omitempty"` + SlotId *uint32 `protobuf:"varint,3,opt,name=slot_id" json:"slot_id,omitempty"` + ChallengeType *uint32 `protobuf:"varint,4,opt,name=challenge_type" json:"challenge_type,omitempty"` + IntParam_0 *uint32 `protobuf:"varint,5,opt,name=int_param_0" json:"int_param_0,omitempty"` + IntParam_1 *uint32 `protobuf:"varint,6,opt,name=int_param_1" json:"int_param_1,omitempty"` + CreatedTime *uint32 `protobuf:"varint,7,opt,name=created_time" json:"created_time,omitempty"` + Completed *uint32 `protobuf:"varint,8,opt,name=completed" json:"completed,omitempty"` + SequenceId *uint32 `protobuf:"varint,9,opt,name=sequence_id" json:"sequence_id,omitempty"` + ChallengeTier *uint32 `protobuf:"varint,10,opt,name=challenge_tier" json:"challenge_tier,omitempty"` + Flags *uint32 `protobuf:"varint,11,opt,name=flags" json:"flags,omitempty"` + Attempts *uint32 `protobuf:"varint,12,opt,name=attempts" json:"attempts,omitempty"` + CompleteLimit *uint32 `protobuf:"varint,13,opt,name=complete_limit" json:"complete_limit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CSODOTAPlayerChallenge) Reset() { *m = CSODOTAPlayerChallenge{} } +func (m *CSODOTAPlayerChallenge) String() string { return proto.CompactTextString(m) } +func (*CSODOTAPlayerChallenge) ProtoMessage() {} +func (*CSODOTAPlayerChallenge) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{46} } + +func (m *CSODOTAPlayerChallenge) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetSlotId() uint32 { + if m != nil && m.SlotId != nil { + return *m.SlotId + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetChallengeType() uint32 { + if m != nil && m.ChallengeType != nil { + return *m.ChallengeType + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetIntParam_0() uint32 { + if m != nil && m.IntParam_0 != nil { + return *m.IntParam_0 + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetIntParam_1() uint32 { + if m != nil && m.IntParam_1 != nil { + return *m.IntParam_1 + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetCreatedTime() uint32 { + if m != nil && m.CreatedTime != nil { + return *m.CreatedTime + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetCompleted() uint32 { + if m != nil && m.Completed != nil { + return *m.Completed + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetSequenceId() uint32 { + if m != nil && m.SequenceId != nil { + return *m.SequenceId + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetChallengeTier() uint32 { + if m != nil && m.ChallengeTier != nil { + return *m.ChallengeTier + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetAttempts() uint32 { + if m != nil && m.Attempts != nil { + return *m.Attempts + } + return 0 +} + +func (m *CSODOTAPlayerChallenge) GetCompleteLimit() uint32 { + if m != nil && m.CompleteLimit != nil { + return *m.CompleteLimit + } + return 0 +} + +type CMsgClientToGCRerollPlayerChallenge struct { + EventId *uint32 `protobuf:"varint,1,opt,name=event_id" json:"event_id,omitempty"` + SequenceId *uint32 `protobuf:"varint,3,opt,name=sequence_id" json:"sequence_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCRerollPlayerChallenge) Reset() { *m = CMsgClientToGCRerollPlayerChallenge{} } +func (m *CMsgClientToGCRerollPlayerChallenge) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCRerollPlayerChallenge) ProtoMessage() {} +func (*CMsgClientToGCRerollPlayerChallenge) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{47} +} + +func (m *CMsgClientToGCRerollPlayerChallenge) GetEventId() uint32 { + if m != nil && m.EventId != nil { + return *m.EventId + } + return 0 +} + +func (m *CMsgClientToGCRerollPlayerChallenge) GetSequenceId() uint32 { + if m != nil && m.SequenceId != nil { + return *m.SequenceId + } + return 0 +} + +type CMsgGCRerollPlayerChallengeResponse struct { + Result *CMsgGCRerollPlayerChallengeResponse_EResult `protobuf:"varint,1,opt,name=result,enum=CMsgGCRerollPlayerChallengeResponse_EResult,def=0" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCRerollPlayerChallengeResponse) Reset() { *m = CMsgGCRerollPlayerChallengeResponse{} } +func (m *CMsgGCRerollPlayerChallengeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCRerollPlayerChallengeResponse) ProtoMessage() {} +func (*CMsgGCRerollPlayerChallengeResponse) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{48} +} + +const Default_CMsgGCRerollPlayerChallengeResponse_Result CMsgGCRerollPlayerChallengeResponse_EResult = CMsgGCRerollPlayerChallengeResponse_eResult_Success + +func (m *CMsgGCRerollPlayerChallengeResponse) GetResult() CMsgGCRerollPlayerChallengeResponse_EResult { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgGCRerollPlayerChallengeResponse_Result +} + +type CMsgGCTopCustomGamesList struct { + TopCustomGames []uint64 `protobuf:"varint,1,rep,name=top_custom_games" json:"top_custom_games,omitempty"` + GameOfTheDay *uint64 `protobuf:"varint,2,opt,name=game_of_the_day" json:"game_of_the_day,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCTopCustomGamesList) Reset() { *m = CMsgGCTopCustomGamesList{} } +func (m *CMsgGCTopCustomGamesList) String() string { return proto.CompactTextString(m) } +func (*CMsgGCTopCustomGamesList) ProtoMessage() {} +func (*CMsgGCTopCustomGamesList) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{49} } + +func (m *CMsgGCTopCustomGamesList) GetTopCustomGames() []uint64 { + if m != nil { + return m.TopCustomGames + } + return nil +} + +func (m *CMsgGCTopCustomGamesList) GetGameOfTheDay() uint64 { + if m != nil && m.GameOfTheDay != nil { + return *m.GameOfTheDay + } + return 0 +} + +type CMsgDOTARealtimeGameStats struct { + Match *CMsgDOTARealtimeGameStats_MatchDetails `protobuf:"bytes,1,opt,name=match" json:"match,omitempty"` + Teams []*CMsgDOTARealtimeGameStats_TeamDetails `protobuf:"bytes,2,rep,name=teams" json:"teams,omitempty"` + Buildings []*CMsgDOTARealtimeGameStats_BuildingDetails `protobuf:"bytes,3,rep,name=buildings" json:"buildings,omitempty"` + GraphData *CMsgDOTARealtimeGameStats_GraphData `protobuf:"bytes,4,opt,name=graph_data" json:"graph_data,omitempty"` + DeltaFrame *bool `protobuf:"varint,5,opt,name=delta_frame" json:"delta_frame,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats) Reset() { *m = CMsgDOTARealtimeGameStats{} } +func (m *CMsgDOTARealtimeGameStats) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{50} } + +func (m *CMsgDOTARealtimeGameStats) GetMatch() *CMsgDOTARealtimeGameStats_MatchDetails { + if m != nil { + return m.Match + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats) GetTeams() []*CMsgDOTARealtimeGameStats_TeamDetails { + if m != nil { + return m.Teams + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats) GetBuildings() []*CMsgDOTARealtimeGameStats_BuildingDetails { + if m != nil { + return m.Buildings + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats) GetGraphData() *CMsgDOTARealtimeGameStats_GraphData { + if m != nil { + return m.GraphData + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats) GetDeltaFrame() bool { + if m != nil && m.DeltaFrame != nil { + return *m.DeltaFrame + } + return false +} + +type CMsgDOTARealtimeGameStats_TeamDetails struct { + TeamNumber *uint32 `protobuf:"varint,1,opt,name=team_number" json:"team_number,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + TeamName *string `protobuf:"bytes,3,opt,name=team_name" json:"team_name,omitempty"` + TeamLogo *uint64 `protobuf:"fixed64,4,opt,name=team_logo" json:"team_logo,omitempty"` + Score *uint32 `protobuf:"varint,5,opt,name=score" json:"score,omitempty"` + Players []*CMsgDOTARealtimeGameStats_PlayerDetails `protobuf:"bytes,6,rep,name=players" json:"players,omitempty"` + OnlyTeam *bool `protobuf:"varint,7,opt,name=only_team" json:"only_team,omitempty"` + Cheers *uint32 `protobuf:"varint,8,opt,name=cheers" json:"cheers,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) Reset() { *m = CMsgDOTARealtimeGameStats_TeamDetails{} } +func (m *CMsgDOTARealtimeGameStats_TeamDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_TeamDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_TeamDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 0} +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetTeamNumber() uint32 { + if m != nil && m.TeamNumber != nil { + return *m.TeamNumber + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetTeamLogo() uint64 { + if m != nil && m.TeamLogo != nil { + return *m.TeamLogo + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetScore() uint32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetPlayers() []*CMsgDOTARealtimeGameStats_PlayerDetails { + if m != nil { + return m.Players + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetOnlyTeam() bool { + if m != nil && m.OnlyTeam != nil { + return *m.OnlyTeam + } + return false +} + +func (m *CMsgDOTARealtimeGameStats_TeamDetails) GetCheers() uint32 { + if m != nil && m.Cheers != nil { + return *m.Cheers + } + return 0 +} + +type CMsgDOTARealtimeGameStats_ItemDetails struct { + Id *uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Time *int32 `protobuf:"varint,3,opt,name=time" json:"time,omitempty"` + Sold *bool `protobuf:"varint,4,opt,name=sold" json:"sold,omitempty"` + Stackcount *uint32 `protobuf:"varint,5,opt,name=stackcount" json:"stackcount,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_ItemDetails) Reset() { *m = CMsgDOTARealtimeGameStats_ItemDetails{} } +func (m *CMsgDOTARealtimeGameStats_ItemDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_ItemDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_ItemDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 1} +} + +func (m *CMsgDOTARealtimeGameStats_ItemDetails) GetId() uint32 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_ItemDetails) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTARealtimeGameStats_ItemDetails) GetTime() int32 { + if m != nil && m.Time != nil { + return *m.Time + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_ItemDetails) GetSold() bool { + if m != nil && m.Sold != nil { + return *m.Sold + } + return false +} + +func (m *CMsgDOTARealtimeGameStats_ItemDetails) GetStackcount() uint32 { + if m != nil && m.Stackcount != nil { + return *m.Stackcount + } + return 0 +} + +type CMsgDOTARealtimeGameStats_AbilityDetails struct { + Id *uint32 `protobuf:"varint,1,opt,name=id" json:"id,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Level *uint32 `protobuf:"varint,3,opt,name=level" json:"level,omitempty"` + Cooldown *float32 `protobuf:"fixed32,4,opt,name=cooldown" json:"cooldown,omitempty"` + CooldownMax *float32 `protobuf:"fixed32,5,opt,name=cooldown_max" json:"cooldown_max,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_AbilityDetails) Reset() { + *m = CMsgDOTARealtimeGameStats_AbilityDetails{} +} +func (m *CMsgDOTARealtimeGameStats_AbilityDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_AbilityDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_AbilityDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 2} +} + +func (m *CMsgDOTARealtimeGameStats_AbilityDetails) GetId() uint32 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_AbilityDetails) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTARealtimeGameStats_AbilityDetails) GetLevel() uint32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_AbilityDetails) GetCooldown() float32 { + if m != nil && m.Cooldown != nil { + return *m.Cooldown + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_AbilityDetails) GetCooldownMax() float32 { + if m != nil && m.CooldownMax != nil { + return *m.CooldownMax + } + return 0 +} + +type CMsgDOTARealtimeGameStats_HeroToHeroStats struct { + Victimid *uint32 `protobuf:"varint,1,opt,name=victimid" json:"victimid,omitempty"` + Kills *uint32 `protobuf:"varint,2,opt,name=kills" json:"kills,omitempty"` + Assists *uint32 `protobuf:"varint,3,opt,name=assists" json:"assists,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_HeroToHeroStats) Reset() { + *m = CMsgDOTARealtimeGameStats_HeroToHeroStats{} +} +func (m *CMsgDOTARealtimeGameStats_HeroToHeroStats) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_HeroToHeroStats) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_HeroToHeroStats) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 3} +} + +func (m *CMsgDOTARealtimeGameStats_HeroToHeroStats) GetVictimid() uint32 { + if m != nil && m.Victimid != nil { + return *m.Victimid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_HeroToHeroStats) GetKills() uint32 { + if m != nil && m.Kills != nil { + return *m.Kills + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_HeroToHeroStats) GetAssists() uint32 { + if m != nil && m.Assists != nil { + return *m.Assists + } + return 0 +} + +type CMsgDOTARealtimeGameStats_AbilityList struct { + Id []uint32 `protobuf:"varint,1,rep,name=id" json:"id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_AbilityList) Reset() { *m = CMsgDOTARealtimeGameStats_AbilityList{} } +func (m *CMsgDOTARealtimeGameStats_AbilityList) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_AbilityList) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_AbilityList) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 4} +} + +func (m *CMsgDOTARealtimeGameStats_AbilityList) GetId() []uint32 { + if m != nil { + return m.Id + } + return nil +} + +type CMsgDOTARealtimeGameStats_PlayerDetails struct { + Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"` + Playerid *uint32 `protobuf:"varint,2,opt,name=playerid" json:"playerid,omitempty"` + Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` + Team *uint32 `protobuf:"varint,4,opt,name=team" json:"team,omitempty"` + Heroid *uint32 `protobuf:"varint,5,opt,name=heroid" json:"heroid,omitempty"` + Healthpoints *uint32 `protobuf:"varint,6,opt,name=healthpoints" json:"healthpoints,omitempty"` + Maxhealthpoints *uint32 `protobuf:"varint,7,opt,name=maxhealthpoints" json:"maxhealthpoints,omitempty"` + Healthregenrate *float32 `protobuf:"fixed32,8,opt,name=healthregenrate" json:"healthregenrate,omitempty"` + Manapoints *uint32 `protobuf:"varint,9,opt,name=manapoints" json:"manapoints,omitempty"` + Maxmanapoints *uint32 `protobuf:"varint,10,opt,name=maxmanapoints" json:"maxmanapoints,omitempty"` + Manaregenrate *float32 `protobuf:"fixed32,11,opt,name=manaregenrate" json:"manaregenrate,omitempty"` + BaseStrength *uint32 `protobuf:"varint,12,opt,name=base_strength" json:"base_strength,omitempty"` + BaseAgility *uint32 `protobuf:"varint,13,opt,name=base_agility" json:"base_agility,omitempty"` + BaseIntelligence *uint32 `protobuf:"varint,14,opt,name=base_intelligence" json:"base_intelligence,omitempty"` + BaseArmor *int32 `protobuf:"varint,15,opt,name=base_armor" json:"base_armor,omitempty"` + BaseMovespeed *uint32 `protobuf:"varint,16,opt,name=base_movespeed" json:"base_movespeed,omitempty"` + BaseDamage *uint32 `protobuf:"varint,17,opt,name=base_damage" json:"base_damage,omitempty"` + Strength *uint32 `protobuf:"varint,18,opt,name=strength" json:"strength,omitempty"` + Agility *uint32 `protobuf:"varint,19,opt,name=agility" json:"agility,omitempty"` + Intelligence *uint32 `protobuf:"varint,20,opt,name=intelligence" json:"intelligence,omitempty"` + Armor *int32 `protobuf:"varint,21,opt,name=armor" json:"armor,omitempty"` + Movespeed *uint32 `protobuf:"varint,22,opt,name=movespeed" json:"movespeed,omitempty"` + Damage *uint32 `protobuf:"varint,23,opt,name=damage" json:"damage,omitempty"` + HeroDamage *uint32 `protobuf:"varint,24,opt,name=hero_damage" json:"hero_damage,omitempty"` + TowerDamage *uint32 `protobuf:"varint,25,opt,name=tower_damage" json:"tower_damage,omitempty"` + Abilities []*CMsgDOTARealtimeGameStats_AbilityDetails `protobuf:"bytes,26,rep,name=abilities" json:"abilities,omitempty"` + Level *uint32 `protobuf:"varint,27,opt,name=level" json:"level,omitempty"` + KillCount *uint32 `protobuf:"varint,28,opt,name=kill_count" json:"kill_count,omitempty"` + DeathCount *uint32 `protobuf:"varint,29,opt,name=death_count" json:"death_count,omitempty"` + AssistsCount *uint32 `protobuf:"varint,30,opt,name=assists_count" json:"assists_count,omitempty"` + DeniesCount *uint32 `protobuf:"varint,31,opt,name=denies_count" json:"denies_count,omitempty"` + LhCount *uint32 `protobuf:"varint,32,opt,name=lh_count" json:"lh_count,omitempty"` + HeroHealing *uint32 `protobuf:"varint,33,opt,name=hero_healing" json:"hero_healing,omitempty"` + GoldPerMin *uint32 `protobuf:"varint,34,opt,name=gold_per_min" json:"gold_per_min,omitempty"` + XpPerMin *uint32 `protobuf:"varint,35,opt,name=xp_per_min" json:"xp_per_min,omitempty"` + NetGold *uint32 `protobuf:"varint,36,opt,name=net_gold" json:"net_gold,omitempty"` + Gold *uint32 `protobuf:"varint,37,opt,name=gold" json:"gold,omitempty"` + X *float32 `protobuf:"fixed32,38,opt,name=x" json:"x,omitempty"` + Y *float32 `protobuf:"fixed32,39,opt,name=y" json:"y,omitempty"` + RespawnTime *int32 `protobuf:"varint,40,opt,name=respawn_time" json:"respawn_time,omitempty"` + UltimateCooldown *uint32 `protobuf:"varint,41,opt,name=ultimate_cooldown" json:"ultimate_cooldown,omitempty"` + HasBuyback *bool `protobuf:"varint,42,opt,name=has_buyback" json:"has_buyback,omitempty"` + Items []*CMsgDOTARealtimeGameStats_ItemDetails `protobuf:"bytes,43,rep,name=items" json:"items,omitempty"` + Stashitems []*CMsgDOTARealtimeGameStats_ItemDetails `protobuf:"bytes,44,rep,name=stashitems" json:"stashitems,omitempty"` + Itemshoppinglist []*CMsgDOTARealtimeGameStats_ItemDetails `protobuf:"bytes,45,rep,name=itemshoppinglist" json:"itemshoppinglist,omitempty"` + Levelpoints []*CMsgDOTARealtimeGameStats_AbilityList `protobuf:"bytes,46,rep,name=levelpoints" json:"levelpoints,omitempty"` + HeroToHeroStats []*CMsgDOTARealtimeGameStats_HeroToHeroStats `protobuf:"bytes,47,rep,name=hero_to_hero_stats" json:"hero_to_hero_stats,omitempty"` + HasUltimate *bool `protobuf:"varint,48,opt,name=has_ultimate" json:"has_ultimate,omitempty"` + HasUltimateMana *bool `protobuf:"varint,49,opt,name=has_ultimate_mana" json:"has_ultimate_mana,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) Reset() { + *m = CMsgDOTARealtimeGameStats_PlayerDetails{} +} +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_PlayerDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_PlayerDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 5} +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetPlayerid() uint32 { + if m != nil && m.Playerid != nil { + return *m.Playerid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetTeam() uint32 { + if m != nil && m.Team != nil { + return *m.Team + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHeroid() uint32 { + if m != nil && m.Heroid != nil { + return *m.Heroid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHealthpoints() uint32 { + if m != nil && m.Healthpoints != nil { + return *m.Healthpoints + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetMaxhealthpoints() uint32 { + if m != nil && m.Maxhealthpoints != nil { + return *m.Maxhealthpoints + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHealthregenrate() float32 { + if m != nil && m.Healthregenrate != nil { + return *m.Healthregenrate + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetManapoints() uint32 { + if m != nil && m.Manapoints != nil { + return *m.Manapoints + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetMaxmanapoints() uint32 { + if m != nil && m.Maxmanapoints != nil { + return *m.Maxmanapoints + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetManaregenrate() float32 { + if m != nil && m.Manaregenrate != nil { + return *m.Manaregenrate + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetBaseStrength() uint32 { + if m != nil && m.BaseStrength != nil { + return *m.BaseStrength + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetBaseAgility() uint32 { + if m != nil && m.BaseAgility != nil { + return *m.BaseAgility + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetBaseIntelligence() uint32 { + if m != nil && m.BaseIntelligence != nil { + return *m.BaseIntelligence + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetBaseArmor() int32 { + if m != nil && m.BaseArmor != nil { + return *m.BaseArmor + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetBaseMovespeed() uint32 { + if m != nil && m.BaseMovespeed != nil { + return *m.BaseMovespeed + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetBaseDamage() uint32 { + if m != nil && m.BaseDamage != nil { + return *m.BaseDamage + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetStrength() uint32 { + if m != nil && m.Strength != nil { + return *m.Strength + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetAgility() uint32 { + if m != nil && m.Agility != nil { + return *m.Agility + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetIntelligence() uint32 { + if m != nil && m.Intelligence != nil { + return *m.Intelligence + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetArmor() int32 { + if m != nil && m.Armor != nil { + return *m.Armor + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetMovespeed() uint32 { + if m != nil && m.Movespeed != nil { + return *m.Movespeed + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetDamage() uint32 { + if m != nil && m.Damage != nil { + return *m.Damage + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHeroDamage() uint32 { + if m != nil && m.HeroDamage != nil { + return *m.HeroDamage + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetTowerDamage() uint32 { + if m != nil && m.TowerDamage != nil { + return *m.TowerDamage + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetAbilities() []*CMsgDOTARealtimeGameStats_AbilityDetails { + if m != nil { + return m.Abilities + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetLevel() uint32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetKillCount() uint32 { + if m != nil && m.KillCount != nil { + return *m.KillCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetDeathCount() uint32 { + if m != nil && m.DeathCount != nil { + return *m.DeathCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetAssistsCount() uint32 { + if m != nil && m.AssistsCount != nil { + return *m.AssistsCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetDeniesCount() uint32 { + if m != nil && m.DeniesCount != nil { + return *m.DeniesCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetLhCount() uint32 { + if m != nil && m.LhCount != nil { + return *m.LhCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHeroHealing() uint32 { + if m != nil && m.HeroHealing != nil { + return *m.HeroHealing + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetGoldPerMin() uint32 { + if m != nil && m.GoldPerMin != nil { + return *m.GoldPerMin + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetXpPerMin() uint32 { + if m != nil && m.XpPerMin != nil { + return *m.XpPerMin + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetNetGold() uint32 { + if m != nil && m.NetGold != nil { + return *m.NetGold + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetGold() uint32 { + if m != nil && m.Gold != nil { + return *m.Gold + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetX() float32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetY() float32 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetRespawnTime() int32 { + if m != nil && m.RespawnTime != nil { + return *m.RespawnTime + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetUltimateCooldown() uint32 { + if m != nil && m.UltimateCooldown != nil { + return *m.UltimateCooldown + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHasBuyback() bool { + if m != nil && m.HasBuyback != nil { + return *m.HasBuyback + } + return false +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetItems() []*CMsgDOTARealtimeGameStats_ItemDetails { + if m != nil { + return m.Items + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetStashitems() []*CMsgDOTARealtimeGameStats_ItemDetails { + if m != nil { + return m.Stashitems + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetItemshoppinglist() []*CMsgDOTARealtimeGameStats_ItemDetails { + if m != nil { + return m.Itemshoppinglist + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetLevelpoints() []*CMsgDOTARealtimeGameStats_AbilityList { + if m != nil { + return m.Levelpoints + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHeroToHeroStats() []*CMsgDOTARealtimeGameStats_HeroToHeroStats { + if m != nil { + return m.HeroToHeroStats + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHasUltimate() bool { + if m != nil && m.HasUltimate != nil { + return *m.HasUltimate + } + return false +} + +func (m *CMsgDOTARealtimeGameStats_PlayerDetails) GetHasUltimateMana() bool { + if m != nil && m.HasUltimateMana != nil { + return *m.HasUltimateMana + } + return false +} + +type CMsgDOTARealtimeGameStats_BuildingDetails struct { + Team *uint32 `protobuf:"varint,2,opt,name=team" json:"team,omitempty"` + Heading *float32 `protobuf:"fixed32,3,opt,name=heading" json:"heading,omitempty"` + Lane *uint32 `protobuf:"varint,4,opt,name=lane" json:"lane,omitempty"` + Tier *uint32 `protobuf:"varint,5,opt,name=tier" json:"tier,omitempty"` + Type *uint32 `protobuf:"varint,6,opt,name=type" json:"type,omitempty"` + X *float32 `protobuf:"fixed32,7,opt,name=x" json:"x,omitempty"` + Y *float32 `protobuf:"fixed32,8,opt,name=y" json:"y,omitempty"` + Destroyed *bool `protobuf:"varint,9,opt,name=destroyed" json:"destroyed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) Reset() { + *m = CMsgDOTARealtimeGameStats_BuildingDetails{} +} +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_BuildingDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_BuildingDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 6} +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetTeam() uint32 { + if m != nil && m.Team != nil { + return *m.Team + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetHeading() float32 { + if m != nil && m.Heading != nil { + return *m.Heading + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetLane() uint32 { + if m != nil && m.Lane != nil { + return *m.Lane + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetTier() uint32 { + if m != nil && m.Tier != nil { + return *m.Tier + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetType() uint32 { + if m != nil && m.Type != nil { + return *m.Type + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetX() float32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetY() float32 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BuildingDetails) GetDestroyed() bool { + if m != nil && m.Destroyed != nil { + return *m.Destroyed + } + return false +} + +type CMsgDOTARealtimeGameStats_KillDetails struct { + PlayerId *uint32 `protobuf:"varint,1,opt,name=player_id" json:"player_id,omitempty"` + DeathTime *int32 `protobuf:"varint,2,opt,name=death_time" json:"death_time,omitempty"` + KillerPlayerId *uint32 `protobuf:"varint,3,opt,name=killer_player_id" json:"killer_player_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_KillDetails) Reset() { *m = CMsgDOTARealtimeGameStats_KillDetails{} } +func (m *CMsgDOTARealtimeGameStats_KillDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_KillDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_KillDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 7} +} + +func (m *CMsgDOTARealtimeGameStats_KillDetails) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_KillDetails) GetDeathTime() int32 { + if m != nil && m.DeathTime != nil { + return *m.DeathTime + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_KillDetails) GetKillerPlayerId() uint32 { + if m != nil && m.KillerPlayerId != nil { + return *m.KillerPlayerId + } + return 0 +} + +type CMsgDOTARealtimeGameStats_BroadcasterDetails struct { + PlayerId *uint32 `protobuf:"varint,1,opt,name=player_id" json:"player_id,omitempty"` + SelectedHero *uint32 `protobuf:"varint,2,opt,name=selected_hero" json:"selected_hero,omitempty"` + SelectedGraph *uint32 `protobuf:"varint,3,opt,name=selected_graph" json:"selected_graph,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_BroadcasterDetails) Reset() { + *m = CMsgDOTARealtimeGameStats_BroadcasterDetails{} +} +func (m *CMsgDOTARealtimeGameStats_BroadcasterDetails) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARealtimeGameStats_BroadcasterDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_BroadcasterDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 8} +} + +func (m *CMsgDOTARealtimeGameStats_BroadcasterDetails) GetPlayerId() uint32 { + if m != nil && m.PlayerId != nil { + return *m.PlayerId + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BroadcasterDetails) GetSelectedHero() uint32 { + if m != nil && m.SelectedHero != nil { + return *m.SelectedHero + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_BroadcasterDetails) GetSelectedGraph() uint32 { + if m != nil && m.SelectedGraph != nil { + return *m.SelectedGraph + } + return 0 +} + +type CMsgDOTARealtimeGameStats_PickBanDetails struct { + Hero *uint32 `protobuf:"varint,1,opt,name=hero" json:"hero,omitempty"` + Team *uint32 `protobuf:"varint,2,opt,name=team" json:"team,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_PickBanDetails) Reset() { + *m = CMsgDOTARealtimeGameStats_PickBanDetails{} +} +func (m *CMsgDOTARealtimeGameStats_PickBanDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_PickBanDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_PickBanDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 9} +} + +func (m *CMsgDOTARealtimeGameStats_PickBanDetails) GetHero() uint32 { + if m != nil && m.Hero != nil { + return *m.Hero + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_PickBanDetails) GetTeam() uint32 { + if m != nil && m.Team != nil { + return *m.Team + } + return 0 +} + +type CMsgDOTARealtimeGameStats_MatchDetails struct { + ServerSteamId *uint64 `protobuf:"fixed64,1,opt,name=server_steam_id" json:"server_steam_id,omitempty"` + Matchid *uint64 `protobuf:"varint,2,opt,name=matchid" json:"matchid,omitempty"` + Timestamp *uint32 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` + TimeOfDay *float32 `protobuf:"fixed32,4,opt,name=time_of_day" json:"time_of_day,omitempty"` + IsNightstalkerNight *bool `protobuf:"varint,5,opt,name=is_nightstalker_night" json:"is_nightstalker_night,omitempty"` + GameTime *int32 `protobuf:"varint,6,opt,name=game_time" json:"game_time,omitempty"` + TeamidRadiant *uint32 `protobuf:"varint,8,opt,name=teamid_radiant" json:"teamid_radiant,omitempty"` + TeamidDire *uint32 `protobuf:"varint,9,opt,name=teamid_dire" json:"teamid_dire,omitempty"` + Picks []*CMsgDOTARealtimeGameStats_PickBanDetails `protobuf:"bytes,10,rep,name=picks" json:"picks,omitempty"` + Bans []*CMsgDOTARealtimeGameStats_PickBanDetails `protobuf:"bytes,11,rep,name=bans" json:"bans,omitempty"` + Kills []*CMsgDOTARealtimeGameStats_KillDetails `protobuf:"bytes,12,rep,name=kills" json:"kills,omitempty"` + Broadcasters []*CMsgDOTARealtimeGameStats_BroadcasterDetails `protobuf:"bytes,13,rep,name=broadcasters" json:"broadcasters,omitempty"` + GameMode *uint32 `protobuf:"varint,14,opt,name=game_mode" json:"game_mode,omitempty"` + LeagueId *uint32 `protobuf:"varint,15,opt,name=league_id" json:"league_id,omitempty"` + SingleTeam *bool `protobuf:"varint,16,opt,name=single_team" json:"single_team,omitempty"` + CheersPeak *uint32 `protobuf:"varint,17,opt,name=cheers_peak" json:"cheers_peak,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) Reset() { + *m = CMsgDOTARealtimeGameStats_MatchDetails{} +} +func (m *CMsgDOTARealtimeGameStats_MatchDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_MatchDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_MatchDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 10} +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetServerSteamId() uint64 { + if m != nil && m.ServerSteamId != nil { + return *m.ServerSteamId + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetMatchid() uint64 { + if m != nil && m.Matchid != nil { + return *m.Matchid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetTimeOfDay() float32 { + if m != nil && m.TimeOfDay != nil { + return *m.TimeOfDay + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetIsNightstalkerNight() bool { + if m != nil && m.IsNightstalkerNight != nil { + return *m.IsNightstalkerNight + } + return false +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetGameTime() int32 { + if m != nil && m.GameTime != nil { + return *m.GameTime + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetTeamidRadiant() uint32 { + if m != nil && m.TeamidRadiant != nil { + return *m.TeamidRadiant + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetTeamidDire() uint32 { + if m != nil && m.TeamidDire != nil { + return *m.TeamidDire + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetPicks() []*CMsgDOTARealtimeGameStats_PickBanDetails { + if m != nil { + return m.Picks + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetBans() []*CMsgDOTARealtimeGameStats_PickBanDetails { + if m != nil { + return m.Bans + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetKills() []*CMsgDOTARealtimeGameStats_KillDetails { + if m != nil { + return m.Kills + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetBroadcasters() []*CMsgDOTARealtimeGameStats_BroadcasterDetails { + if m != nil { + return m.Broadcasters + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetSingleTeam() bool { + if m != nil && m.SingleTeam != nil { + return *m.SingleTeam + } + return false +} + +func (m *CMsgDOTARealtimeGameStats_MatchDetails) GetCheersPeak() uint32 { + if m != nil && m.CheersPeak != nil { + return *m.CheersPeak + } + return 0 +} + +type CMsgDOTARealtimeGameStats_GraphData struct { + GraphGold []int32 `protobuf:"varint,1,rep,name=graph_gold" json:"graph_gold,omitempty"` + GraphXp []int32 `protobuf:"varint,2,rep,name=graph_xp" json:"graph_xp,omitempty"` + GraphKill []int32 `protobuf:"varint,3,rep,name=graph_kill" json:"graph_kill,omitempty"` + GraphTower []int32 `protobuf:"varint,4,rep,name=graph_tower" json:"graph_tower,omitempty"` + GraphRax []int32 `protobuf:"varint,5,rep,name=graph_rax" json:"graph_rax,omitempty"` + TeamLocStats []*CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats `protobuf:"bytes,6,rep,name=team_loc_stats" json:"team_loc_stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_GraphData) Reset() { *m = CMsgDOTARealtimeGameStats_GraphData{} } +func (m *CMsgDOTARealtimeGameStats_GraphData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStats_GraphData) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_GraphData) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 11} +} + +func (m *CMsgDOTARealtimeGameStats_GraphData) GetGraphGold() []int32 { + if m != nil { + return m.GraphGold + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_GraphData) GetGraphXp() []int32 { + if m != nil { + return m.GraphXp + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_GraphData) GetGraphKill() []int32 { + if m != nil { + return m.GraphKill + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_GraphData) GetGraphTower() []int32 { + if m != nil { + return m.GraphTower + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_GraphData) GetGraphRax() []int32 { + if m != nil { + return m.GraphRax + } + return nil +} + +func (m *CMsgDOTARealtimeGameStats_GraphData) GetTeamLocStats() []*CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats { + if m != nil { + return m.TeamLocStats + } + return nil +} + +type CMsgDOTARealtimeGameStats_GraphData_LocationStats struct { + Stats []int32 `protobuf:"varint,1,rep,name=stats" json:"stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_GraphData_LocationStats) Reset() { + *m = CMsgDOTARealtimeGameStats_GraphData_LocationStats{} +} +func (m *CMsgDOTARealtimeGameStats_GraphData_LocationStats) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARealtimeGameStats_GraphData_LocationStats) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_GraphData_LocationStats) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 11, 0} +} + +func (m *CMsgDOTARealtimeGameStats_GraphData_LocationStats) GetStats() []int32 { + if m != nil { + return m.Stats + } + return nil +} + +type CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats struct { + LocStats []*CMsgDOTARealtimeGameStats_GraphData_LocationStats `protobuf:"bytes,1,rep,name=loc_stats" json:"loc_stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats) Reset() { + *m = CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats{} +} +func (m *CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{50, 11, 1} +} + +func (m *CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats) GetLocStats() []*CMsgDOTARealtimeGameStats_GraphData_LocationStats { + if m != nil { + return m.LocStats + } + return nil +} + +type CMsgDOTARealtimeGameStatsTerse struct { + Match *CMsgDOTARealtimeGameStatsTerse_MatchDetails `protobuf:"bytes,1,opt,name=match" json:"match,omitempty"` + Teams []*CMsgDOTARealtimeGameStatsTerse_TeamDetails `protobuf:"bytes,2,rep,name=teams" json:"teams,omitempty"` + Buildings []*CMsgDOTARealtimeGameStatsTerse_BuildingDetails `protobuf:"bytes,3,rep,name=buildings" json:"buildings,omitempty"` + GraphData *CMsgDOTARealtimeGameStatsTerse_GraphData `protobuf:"bytes,4,opt,name=graph_data" json:"graph_data,omitempty"` + DeltaFrame *bool `protobuf:"varint,5,opt,name=delta_frame" json:"delta_frame,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStatsTerse) Reset() { *m = CMsgDOTARealtimeGameStatsTerse{} } +func (m *CMsgDOTARealtimeGameStatsTerse) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStatsTerse) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStatsTerse) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{51} } + +func (m *CMsgDOTARealtimeGameStatsTerse) GetMatch() *CMsgDOTARealtimeGameStatsTerse_MatchDetails { + if m != nil { + return m.Match + } + return nil +} + +func (m *CMsgDOTARealtimeGameStatsTerse) GetTeams() []*CMsgDOTARealtimeGameStatsTerse_TeamDetails { + if m != nil { + return m.Teams + } + return nil +} + +func (m *CMsgDOTARealtimeGameStatsTerse) GetBuildings() []*CMsgDOTARealtimeGameStatsTerse_BuildingDetails { + if m != nil { + return m.Buildings + } + return nil +} + +func (m *CMsgDOTARealtimeGameStatsTerse) GetGraphData() *CMsgDOTARealtimeGameStatsTerse_GraphData { + if m != nil { + return m.GraphData + } + return nil +} + +func (m *CMsgDOTARealtimeGameStatsTerse) GetDeltaFrame() bool { + if m != nil && m.DeltaFrame != nil { + return *m.DeltaFrame + } + return false +} + +type CMsgDOTARealtimeGameStatsTerse_TeamDetails struct { + TeamNumber *uint32 `protobuf:"varint,1,opt,name=team_number" json:"team_number,omitempty"` + TeamId *uint32 `protobuf:"varint,2,opt,name=team_id" json:"team_id,omitempty"` + TeamName *string `protobuf:"bytes,3,opt,name=team_name" json:"team_name,omitempty"` + TeamLogo *uint64 `protobuf:"fixed64,4,opt,name=team_logo" json:"team_logo,omitempty"` + Score *uint32 `protobuf:"varint,5,opt,name=score" json:"score,omitempty"` + Players []*CMsgDOTARealtimeGameStatsTerse_PlayerDetails `protobuf:"bytes,6,rep,name=players" json:"players,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) Reset() { + *m = CMsgDOTARealtimeGameStatsTerse_TeamDetails{} +} +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARealtimeGameStatsTerse_TeamDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStatsTerse_TeamDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{51, 0} +} + +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) GetTeamNumber() uint32 { + if m != nil && m.TeamNumber != nil { + return *m.TeamNumber + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) GetTeamName() string { + if m != nil && m.TeamName != nil { + return *m.TeamName + } + return "" +} + +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) GetTeamLogo() uint64 { + if m != nil && m.TeamLogo != nil { + return *m.TeamLogo + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) GetScore() uint32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_TeamDetails) GetPlayers() []*CMsgDOTARealtimeGameStatsTerse_PlayerDetails { + if m != nil { + return m.Players + } + return nil +} + +type CMsgDOTARealtimeGameStatsTerse_PlayerDetails struct { + Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"` + Playerid *uint32 `protobuf:"varint,2,opt,name=playerid" json:"playerid,omitempty"` + Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` + Team *uint32 `protobuf:"varint,4,opt,name=team" json:"team,omitempty"` + Heroid *uint32 `protobuf:"varint,5,opt,name=heroid" json:"heroid,omitempty"` + Level *uint32 `protobuf:"varint,6,opt,name=level" json:"level,omitempty"` + KillCount *uint32 `protobuf:"varint,7,opt,name=kill_count" json:"kill_count,omitempty"` + DeathCount *uint32 `protobuf:"varint,8,opt,name=death_count" json:"death_count,omitempty"` + AssistsCount *uint32 `protobuf:"varint,9,opt,name=assists_count" json:"assists_count,omitempty"` + DeniesCount *uint32 `protobuf:"varint,10,opt,name=denies_count" json:"denies_count,omitempty"` + LhCount *uint32 `protobuf:"varint,11,opt,name=lh_count" json:"lh_count,omitempty"` + Gold *uint32 `protobuf:"varint,12,opt,name=gold" json:"gold,omitempty"` + X *float32 `protobuf:"fixed32,13,opt,name=x" json:"x,omitempty"` + Y *float32 `protobuf:"fixed32,14,opt,name=y" json:"y,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) Reset() { + *m = CMsgDOTARealtimeGameStatsTerse_PlayerDetails{} +} +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARealtimeGameStatsTerse_PlayerDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStatsTerse_PlayerDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{51, 1} +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetPlayerid() uint32 { + if m != nil && m.Playerid != nil { + return *m.Playerid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetTeam() uint32 { + if m != nil && m.Team != nil { + return *m.Team + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetHeroid() uint32 { + if m != nil && m.Heroid != nil { + return *m.Heroid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetLevel() uint32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetKillCount() uint32 { + if m != nil && m.KillCount != nil { + return *m.KillCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetDeathCount() uint32 { + if m != nil && m.DeathCount != nil { + return *m.DeathCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetAssistsCount() uint32 { + if m != nil && m.AssistsCount != nil { + return *m.AssistsCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetDeniesCount() uint32 { + if m != nil && m.DeniesCount != nil { + return *m.DeniesCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetLhCount() uint32 { + if m != nil && m.LhCount != nil { + return *m.LhCount + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetGold() uint32 { + if m != nil && m.Gold != nil { + return *m.Gold + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetX() float32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_PlayerDetails) GetY() float32 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +type CMsgDOTARealtimeGameStatsTerse_BuildingDetails struct { + Team *uint32 `protobuf:"varint,1,opt,name=team" json:"team,omitempty"` + Heading *float32 `protobuf:"fixed32,2,opt,name=heading" json:"heading,omitempty"` + Type *uint32 `protobuf:"varint,3,opt,name=type" json:"type,omitempty"` + Lane *uint32 `protobuf:"varint,4,opt,name=lane" json:"lane,omitempty"` + Tier *uint32 `protobuf:"varint,5,opt,name=tier" json:"tier,omitempty"` + X *float32 `protobuf:"fixed32,6,opt,name=x" json:"x,omitempty"` + Y *float32 `protobuf:"fixed32,7,opt,name=y" json:"y,omitempty"` + Destroyed *bool `protobuf:"varint,8,opt,name=destroyed" json:"destroyed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) Reset() { + *m = CMsgDOTARealtimeGameStatsTerse_BuildingDetails{} +} +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARealtimeGameStatsTerse_BuildingDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStatsTerse_BuildingDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{51, 2} +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetTeam() uint32 { + if m != nil && m.Team != nil { + return *m.Team + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetHeading() float32 { + if m != nil && m.Heading != nil { + return *m.Heading + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetType() uint32 { + if m != nil && m.Type != nil { + return *m.Type + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetLane() uint32 { + if m != nil && m.Lane != nil { + return *m.Lane + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetTier() uint32 { + if m != nil && m.Tier != nil { + return *m.Tier + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetX() float32 { + if m != nil && m.X != nil { + return *m.X + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetY() float32 { + if m != nil && m.Y != nil { + return *m.Y + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_BuildingDetails) GetDestroyed() bool { + if m != nil && m.Destroyed != nil { + return *m.Destroyed + } + return false +} + +type CMsgDOTARealtimeGameStatsTerse_MatchDetails struct { + ServerSteamId *uint64 `protobuf:"fixed64,1,opt,name=server_steam_id" json:"server_steam_id,omitempty"` + Matchid *uint64 `protobuf:"varint,2,opt,name=matchid" json:"matchid,omitempty"` + Timestamp *uint32 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` + GameTime *int32 `protobuf:"varint,4,opt,name=game_time" json:"game_time,omitempty"` + SteamBroadcasterAccountIds []uint32 `protobuf:"varint,6,rep,name=steam_broadcaster_account_ids" json:"steam_broadcaster_account_ids,omitempty"` + GameMode *uint32 `protobuf:"varint,7,opt,name=game_mode" json:"game_mode,omitempty"` + LeagueId *uint32 `protobuf:"varint,8,opt,name=league_id" json:"league_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) Reset() { + *m = CMsgDOTARealtimeGameStatsTerse_MatchDetails{} +} +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) String() string { + return proto.CompactTextString(m) +} +func (*CMsgDOTARealtimeGameStatsTerse_MatchDetails) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStatsTerse_MatchDetails) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{51, 3} +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) GetServerSteamId() uint64 { + if m != nil && m.ServerSteamId != nil { + return *m.ServerSteamId + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) GetMatchid() uint64 { + if m != nil && m.Matchid != nil { + return *m.Matchid + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) GetGameTime() int32 { + if m != nil && m.GameTime != nil { + return *m.GameTime + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) GetSteamBroadcasterAccountIds() []uint32 { + if m != nil { + return m.SteamBroadcasterAccountIds + } + return nil +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CMsgDOTARealtimeGameStatsTerse_MatchDetails) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +type CMsgDOTARealtimeGameStatsTerse_GraphData struct { + GraphGold []int32 `protobuf:"varint,1,rep,name=graph_gold" json:"graph_gold,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTARealtimeGameStatsTerse_GraphData) Reset() { + *m = CMsgDOTARealtimeGameStatsTerse_GraphData{} +} +func (m *CMsgDOTARealtimeGameStatsTerse_GraphData) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTARealtimeGameStatsTerse_GraphData) ProtoMessage() {} +func (*CMsgDOTARealtimeGameStatsTerse_GraphData) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{51, 4} +} + +func (m *CMsgDOTARealtimeGameStatsTerse_GraphData) GetGraphGold() []int32 { + if m != nil { + return m.GraphGold + } + return nil +} + +type CMsgGCToClientMatchGroupsVersion struct { + MatchgroupsVersion *uint32 `protobuf:"varint,1,opt,name=matchgroups_version" json:"matchgroups_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientMatchGroupsVersion) Reset() { *m = CMsgGCToClientMatchGroupsVersion{} } +func (m *CMsgGCToClientMatchGroupsVersion) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientMatchGroupsVersion) ProtoMessage() {} +func (*CMsgGCToClientMatchGroupsVersion) Descriptor() ([]byte, []int) { + return dota_common_fileDescriptor0, []int{52} +} + +func (m *CMsgGCToClientMatchGroupsVersion) GetMatchgroupsVersion() uint32 { + if m != nil && m.MatchgroupsVersion != nil { + return *m.MatchgroupsVersion + } + return 0 +} + +type CMsgDOTASDOHeroStatsHistory struct { + MatchId *uint64 `protobuf:"varint,1,opt,name=match_id" json:"match_id,omitempty"` + GameMode *uint32 `protobuf:"varint,2,opt,name=game_mode" json:"game_mode,omitempty"` + LobbyType *uint32 `protobuf:"varint,3,opt,name=lobby_type" json:"lobby_type,omitempty"` + StartTime *uint32 `protobuf:"varint,4,opt,name=start_time" json:"start_time,omitempty"` + Won *bool `protobuf:"varint,5,opt,name=won" json:"won,omitempty"` + Gpm *uint32 `protobuf:"varint,6,opt,name=gpm" json:"gpm,omitempty"` + Xpm *uint32 `protobuf:"varint,7,opt,name=xpm" json:"xpm,omitempty"` + Kills *uint32 `protobuf:"varint,8,opt,name=kills" json:"kills,omitempty"` + Deaths *uint32 `protobuf:"varint,9,opt,name=deaths" json:"deaths,omitempty"` + Assists *uint32 `protobuf:"varint,10,opt,name=assists" json:"assists,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDOTASDOHeroStatsHistory) Reset() { *m = CMsgDOTASDOHeroStatsHistory{} } +func (m *CMsgDOTASDOHeroStatsHistory) String() string { return proto.CompactTextString(m) } +func (*CMsgDOTASDOHeroStatsHistory) ProtoMessage() {} +func (*CMsgDOTASDOHeroStatsHistory) Descriptor() ([]byte, []int) { return dota_common_fileDescriptor0, []int{53} } + +func (m *CMsgDOTASDOHeroStatsHistory) GetMatchId() uint64 { + if m != nil && m.MatchId != nil { + return *m.MatchId + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetGameMode() uint32 { + if m != nil && m.GameMode != nil { + return *m.GameMode + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetLobbyType() uint32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetWon() bool { + if m != nil && m.Won != nil { + return *m.Won + } + return false +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetGpm() uint32 { + if m != nil && m.Gpm != nil { + return *m.Gpm + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetXpm() uint32 { + if m != nil && m.Xpm != nil { + return *m.Xpm + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetKills() uint32 { + if m != nil && m.Kills != nil { + return *m.Kills + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetDeaths() uint32 { + if m != nil && m.Deaths != nil { + return *m.Deaths + } + return 0 +} + +func (m *CMsgDOTASDOHeroStatsHistory) GetAssists() uint32 { + if m != nil && m.Assists != nil { + return *m.Assists + } + return 0 +} + +func init() { + proto.RegisterType((*CSODOTAGameAccountClient)(nil), "CSODOTAGameAccountClient") + proto.RegisterType((*CSODOTAPartyMember)(nil), "CSODOTAPartyMember") + proto.RegisterType((*CSODOTAParty)(nil), "CSODOTAParty") + proto.RegisterType((*CSODOTAPartyInvite)(nil), "CSODOTAPartyInvite") + proto.RegisterType((*CSODOTAPartyInvite_PartyMember)(nil), "CSODOTAPartyInvite.PartyMember") + proto.RegisterType((*CSODOTALobbyInvite)(nil), "CSODOTALobbyInvite") + proto.RegisterType((*CSODOTALobbyInvite_LobbyMember)(nil), "CSODOTALobbyInvite.LobbyMember") + proto.RegisterType((*CDOTAClientHardwareSpecs)(nil), "CDOTAClientHardwareSpecs") + proto.RegisterType((*CDOTASaveGame)(nil), "CDOTASaveGame") + proto.RegisterType((*CDOTASaveGame_Player)(nil), "CDOTASaveGame.Player") + proto.RegisterType((*CDOTASaveGame_SaveInstance)(nil), "CDOTASaveGame.SaveInstance") + proto.RegisterType((*CDOTASaveGame_SaveInstance_PlayerPositions)(nil), "CDOTASaveGame.SaveInstance.PlayerPositions") + proto.RegisterType((*CMsgLeaverState)(nil), "CMsgLeaverState") + proto.RegisterType((*CDOTALobbyMember)(nil), "CDOTALobbyMember") + proto.RegisterType((*CDOTALobbyMember_CDOTALobbyMemberXPBonus)(nil), "CDOTALobbyMember.CDOTALobbyMemberXPBonus") + proto.RegisterType((*CLobbyTeamDetails)(nil), "CLobbyTeamDetails") + proto.RegisterType((*CLobbyTimedRewardDetails)(nil), "CLobbyTimedRewardDetails") + proto.RegisterType((*CLobbyBroadcastChannelInfo)(nil), "CLobbyBroadcastChannelInfo") + proto.RegisterType((*CSODOTALobby)(nil), "CSODOTALobby") + proto.RegisterType((*CSODOTALobby_CExtraMsg)(nil), "CSODOTALobby.CExtraMsg") + proto.RegisterType((*CMsgLobbyEventPoints)(nil), "CMsgLobbyEventPoints") + proto.RegisterType((*CMsgLobbyEventPoints_AccountPoints)(nil), "CMsgLobbyEventPoints.AccountPoints") + proto.RegisterType((*CMsgDOTABroadcastNotification)(nil), "CMsgDOTABroadcastNotification") + proto.RegisterType((*CMsgDOTAPCBangTimedReward)(nil), "CMsgDOTAPCBangTimedReward") + proto.RegisterType((*CProtoItemHeroStatue)(nil), "CProtoItemHeroStatue") + proto.RegisterType((*CProtoItemTeamShowcase)(nil), "CProtoItemTeamShowcase") + proto.RegisterType((*CMatchPlayerAbilityUpgrade)(nil), "CMatchPlayerAbilityUpgrade") + proto.RegisterType((*CMatchAdditionalUnitInventory)(nil), "CMatchAdditionalUnitInventory") + proto.RegisterType((*CMatchHeroSelectEvent)(nil), "CMatchHeroSelectEvent") + proto.RegisterType((*CMsgDOTAProcessFantasyScheduledEvent)(nil), "CMsgDOTAProcessFantasyScheduledEvent") + proto.RegisterType((*CMsgDOTAHasItemQuery)(nil), "CMsgDOTAHasItemQuery") + proto.RegisterType((*CMsgDOTAHasItemResponse)(nil), "CMsgDOTAHasItemResponse") + proto.RegisterType((*CMsgDOTAHasItemDefsQuery)(nil), "CMsgDOTAHasItemDefsQuery") + proto.RegisterType((*CMsgDOTAHasItemDefsResponse)(nil), "CMsgDOTAHasItemDefsResponse") + proto.RegisterType((*CMsgDOTAConsumeFantasyTicket)(nil), "CMsgDOTAConsumeFantasyTicket") + proto.RegisterType((*CMsgDOTAConsumeFantasyTicketFailure)(nil), "CMsgDOTAConsumeFantasyTicketFailure") + proto.RegisterType((*CMsgGCToGCFantasySetMatchLeague)(nil), "CMsgGCToGCFantasySetMatchLeague") + proto.RegisterType((*CSODOTAMapLocationState)(nil), "CSODOTAMapLocationState") + proto.RegisterType((*CMsgNexonPartnerUpdate)(nil), "CMsgNexonPartnerUpdate") + proto.RegisterType((*CMsgMakeOffering)(nil), "CMsgMakeOffering") + proto.RegisterType((*CMsgRequestOfferings)(nil), "CMsgRequestOfferings") + proto.RegisterType((*CMsgRequestOfferingsResponse)(nil), "CMsgRequestOfferingsResponse") + proto.RegisterType((*CMsgRequestOfferingsResponse_NewYearsOffering)(nil), "CMsgRequestOfferingsResponse.NewYearsOffering") + proto.RegisterType((*CMsgLeagueAdminList)(nil), "CMsgLeagueAdminList") + proto.RegisterType((*CMsgPerfectWorldUserLookupRequest)(nil), "CMsgPerfectWorldUserLookupRequest") + proto.RegisterType((*CMsgPerfectWorldUserLookupResponse)(nil), "CMsgPerfectWorldUserLookupResponse") + proto.RegisterType((*CCompendiumTimestampedData)(nil), "CCompendiumTimestampedData") + proto.RegisterType((*CCompendiumGameTimeline)(nil), "CCompendiumGameTimeline") + proto.RegisterType((*CCompendiumGameList)(nil), "CCompendiumGameList") + proto.RegisterType((*CAdditionalEquipSlot)(nil), "CAdditionalEquipSlot") + proto.RegisterType((*CMsgDOTARedeemItem)(nil), "CMsgDOTARedeemItem") + proto.RegisterType((*CMsgDOTARedeemItemResponse)(nil), "CMsgDOTARedeemItemResponse") + proto.RegisterType((*CMsgDOTACombatLogEntry)(nil), "CMsgDOTACombatLogEntry") + proto.RegisterType((*CMsgDOTAProfileCard)(nil), "CMsgDOTAProfileCard") + proto.RegisterType((*CMsgDOTAProfileCard_Slot)(nil), "CMsgDOTAProfileCard.Slot") + proto.RegisterType((*CMsgDOTAProfileCard_Slot_Trophy)(nil), "CMsgDOTAProfileCard.Slot.Trophy") + proto.RegisterType((*CMsgDOTAProfileCard_Slot_Stat)(nil), "CMsgDOTAProfileCard.Slot.Stat") + proto.RegisterType((*CMsgDOTAProfileCard_Slot_Item)(nil), "CMsgDOTAProfileCard.Slot.Item") + proto.RegisterType((*CMsgDOTAProfileCard_Slot_Hero)(nil), "CMsgDOTAProfileCard.Slot.Hero") + proto.RegisterType((*CMsgDOTAProfileCard_Slot_Emoticon)(nil), "CMsgDOTAProfileCard.Slot.Emoticon") + proto.RegisterType((*CMsgGCToClientNewBloomTimingUpdated)(nil), "CMsgGCToClientNewBloomTimingUpdated") + proto.RegisterType((*CSODOTAPlayerChallenge)(nil), "CSODOTAPlayerChallenge") + proto.RegisterType((*CMsgClientToGCRerollPlayerChallenge)(nil), "CMsgClientToGCRerollPlayerChallenge") + proto.RegisterType((*CMsgGCRerollPlayerChallengeResponse)(nil), "CMsgGCRerollPlayerChallengeResponse") + proto.RegisterType((*CMsgGCTopCustomGamesList)(nil), "CMsgGCTopCustomGamesList") + proto.RegisterType((*CMsgDOTARealtimeGameStats)(nil), "CMsgDOTARealtimeGameStats") + proto.RegisterType((*CMsgDOTARealtimeGameStats_TeamDetails)(nil), "CMsgDOTARealtimeGameStats.TeamDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_ItemDetails)(nil), "CMsgDOTARealtimeGameStats.ItemDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_AbilityDetails)(nil), "CMsgDOTARealtimeGameStats.AbilityDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_HeroToHeroStats)(nil), "CMsgDOTARealtimeGameStats.HeroToHeroStats") + proto.RegisterType((*CMsgDOTARealtimeGameStats_AbilityList)(nil), "CMsgDOTARealtimeGameStats.AbilityList") + proto.RegisterType((*CMsgDOTARealtimeGameStats_PlayerDetails)(nil), "CMsgDOTARealtimeGameStats.PlayerDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_BuildingDetails)(nil), "CMsgDOTARealtimeGameStats.BuildingDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_KillDetails)(nil), "CMsgDOTARealtimeGameStats.KillDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_BroadcasterDetails)(nil), "CMsgDOTARealtimeGameStats.BroadcasterDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_PickBanDetails)(nil), "CMsgDOTARealtimeGameStats.PickBanDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_MatchDetails)(nil), "CMsgDOTARealtimeGameStats.MatchDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStats_GraphData)(nil), "CMsgDOTARealtimeGameStats.GraphData") + proto.RegisterType((*CMsgDOTARealtimeGameStats_GraphData_LocationStats)(nil), "CMsgDOTARealtimeGameStats.GraphData.LocationStats") + proto.RegisterType((*CMsgDOTARealtimeGameStats_GraphData_TeamLocationStats)(nil), "CMsgDOTARealtimeGameStats.GraphData.TeamLocationStats") + proto.RegisterType((*CMsgDOTARealtimeGameStatsTerse)(nil), "CMsgDOTARealtimeGameStatsTerse") + proto.RegisterType((*CMsgDOTARealtimeGameStatsTerse_TeamDetails)(nil), "CMsgDOTARealtimeGameStatsTerse.TeamDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStatsTerse_PlayerDetails)(nil), "CMsgDOTARealtimeGameStatsTerse.PlayerDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStatsTerse_BuildingDetails)(nil), "CMsgDOTARealtimeGameStatsTerse.BuildingDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStatsTerse_MatchDetails)(nil), "CMsgDOTARealtimeGameStatsTerse.MatchDetails") + proto.RegisterType((*CMsgDOTARealtimeGameStatsTerse_GraphData)(nil), "CMsgDOTARealtimeGameStatsTerse.GraphData") + proto.RegisterType((*CMsgGCToClientMatchGroupsVersion)(nil), "CMsgGCToClientMatchGroupsVersion") + proto.RegisterType((*CMsgDOTASDOHeroStatsHistory)(nil), "CMsgDOTASDOHeroStatsHistory") + proto.RegisterEnum("EDOTAGCMsg", EDOTAGCMsg_name, EDOTAGCMsg_value) + proto.RegisterEnum("ESpecialPingValue", ESpecialPingValue_name, ESpecialPingValue_value) + proto.RegisterEnum("DOTA_GameMode", DOTA_GameMode_name, DOTA_GameMode_value) + proto.RegisterEnum("DOTA_GameState", DOTA_GameState_name, DOTA_GameState_value) + proto.RegisterEnum("DOTA_GC_TEAM", DOTA_GC_TEAM_name, DOTA_GC_TEAM_value) + proto.RegisterEnum("DOTA_CM_PICK", DOTA_CM_PICK_name, DOTA_CM_PICK_value) + proto.RegisterEnum("DOTAConnectionStateT", DOTAConnectionStateT_name, DOTAConnectionStateT_value) + proto.RegisterEnum("DOTALeaverStatusT", DOTALeaverStatusT_name, DOTALeaverStatusT_value) + proto.RegisterEnum("DOTALowPriorityBanType", DOTALowPriorityBanType_name, DOTALowPriorityBanType_value) + proto.RegisterEnum("DOTALobbyReadyState", DOTALobbyReadyState_name, DOTALobbyReadyState_value) + proto.RegisterEnum("DOTAGameVersion", DOTAGameVersion_name, DOTAGameVersion_value) + proto.RegisterEnum("DOTAJoinLobbyResult", DOTAJoinLobbyResult_name, DOTAJoinLobbyResult_value) + proto.RegisterEnum("SelectionPriorityType", SelectionPriorityType_name, SelectionPriorityType_value) + proto.RegisterEnum("DOTAMatchVote", DOTAMatchVote_name, DOTAMatchVote_value) + proto.RegisterEnum("DOTA_LobbyMemberXPBonus", DOTA_LobbyMemberXPBonus_name, DOTA_LobbyMemberXPBonus_value) + proto.RegisterEnum("DOTALobbyVisibility", DOTALobbyVisibility_name, DOTALobbyVisibility_value) + proto.RegisterEnum("EDOTAPlayerMMRType", EDOTAPlayerMMRType_name, EDOTAPlayerMMRType_value) + proto.RegisterEnum("MatchType", MatchType_name, MatchType_value) + proto.RegisterEnum("DOTABotDifficulty", DOTABotDifficulty_name, DOTABotDifficulty_value) + proto.RegisterEnum("MatchLanguages", MatchLanguages_name, MatchLanguages_value) + proto.RegisterEnum("ETournamentTemplate", ETournamentTemplate_name, ETournamentTemplate_value) + proto.RegisterEnum("ETournamentType", ETournamentType_name, ETournamentType_value) + proto.RegisterEnum("EEvent", EEvent_name, EEvent_value) + proto.RegisterEnum("LobbyDotaTVDelay", LobbyDotaTVDelay_name, LobbyDotaTVDelay_value) + proto.RegisterEnum("LobbyDotaPauseSetting", LobbyDotaPauseSetting_name, LobbyDotaPauseSetting_value) + proto.RegisterEnum("EMatchOutcome", EMatchOutcome_name, EMatchOutcome_value) + proto.RegisterEnum("EDOTAGCSessionNeed", EDOTAGCSessionNeed_name, EDOTAGCSessionNeed_value) + proto.RegisterEnum("Fantasy_Roles", Fantasy_Roles_name, Fantasy_Roles_value) + proto.RegisterEnum("Fantasy_Team_Slots", Fantasy_Team_Slots_name, Fantasy_Team_Slots_value) + proto.RegisterEnum("Fantasy_Selection_Mode", Fantasy_Selection_Mode_name, Fantasy_Selection_Mode_value) + proto.RegisterEnum("DOTA_TournamentEvents", DOTA_TournamentEvents_name, DOTA_TournamentEvents_value) + proto.RegisterEnum("DOTA_COMBATLOG_TYPES", DOTA_COMBATLOG_TYPES_name, DOTA_COMBATLOG_TYPES_value) + proto.RegisterEnum("DOTAChatChannelTypeT", DOTAChatChannelTypeT_name, DOTAChatChannelTypeT_value) + proto.RegisterEnum("CSODOTAParty_State", CSODOTAParty_State_name, CSODOTAParty_State_value) + proto.RegisterEnum("CSODOTALobby_State", CSODOTALobby_State_name, CSODOTALobby_State_value) + proto.RegisterEnum("CSODOTALobby_LobbyType", CSODOTALobby_LobbyType_name, CSODOTALobby_LobbyType_value) + proto.RegisterEnum("CMsgPerfectWorldUserLookupResponse_EResultCode", CMsgPerfectWorldUserLookupResponse_EResultCode_name, CMsgPerfectWorldUserLookupResponse_EResultCode_value) + proto.RegisterEnum("CMsgDOTARedeemItemResponse_EResultCode", CMsgDOTARedeemItemResponse_EResultCode_name, CMsgDOTARedeemItemResponse_EResultCode_value) + proto.RegisterEnum("CMsgDOTAProfileCard_EStatID", CMsgDOTAProfileCard_EStatID_name, CMsgDOTAProfileCard_EStatID_value) + proto.RegisterEnum("CSODOTAPlayerChallenge_EFlags", CSODOTAPlayerChallenge_EFlags_name, CSODOTAPlayerChallenge_EFlags_value) + proto.RegisterEnum("CMsgGCRerollPlayerChallengeResponse_EResult", CMsgGCRerollPlayerChallengeResponse_EResult_name, CMsgGCRerollPlayerChallengeResponse_EResult_value) + proto.RegisterEnum("CMsgDOTARealtimeGameStats_GraphDataEStat", CMsgDOTARealtimeGameStats_GraphDataEStat_name, CMsgDOTARealtimeGameStats_GraphDataEStat_value) + proto.RegisterEnum("CMsgDOTARealtimeGameStats_GraphDataELocation", CMsgDOTARealtimeGameStats_GraphDataELocation_name, CMsgDOTARealtimeGameStats_GraphDataELocation_value) +} + +var dota_common_fileDescriptor0 = []byte{ + // 17253 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xcc, 0xbd, 0x69, 0x78, 0x5b, 0xd7, + 0x75, 0x28, 0x6a, 0x8e, 0xa2, 0x0e, 0x25, 0x6a, 0x0b, 0x96, 0x64, 0x8a, 0xb6, 0x65, 0x9b, 0x76, + 0x3c, 0xd0, 0x36, 0x2d, 0xc9, 0x8e, 0x48, 0x82, 0xb7, 0x64, 0x41, 0x00, 0xa4, 0x10, 0x81, 0x00, + 0x0c, 0x80, 0x92, 0xf5, 0xfa, 0xbe, 0x7b, 0xbe, 0x23, 0xe0, 0x90, 0x44, 0x05, 0xe2, 0x30, 0x38, + 0x80, 0x64, 0xf6, 0xfb, 0xde, 0x77, 0x9d, 0x38, 0x75, 0x9a, 0xa1, 0x69, 0x92, 0x26, 0x6d, 0x92, + 0xa6, 0x71, 0x9a, 0x34, 0x69, 0xa6, 0x36, 0x63, 0x73, 0x9b, 0xa6, 0x43, 0xd2, 0xf6, 0xb6, 0x49, + 0xd3, 0x0c, 0x9d, 0x32, 0x35, 0xc3, 0x4d, 0x9b, 0x39, 0xcd, 0x70, 0x33, 0x4f, 0x4d, 0xde, 0x5a, + 0x6b, 0x0f, 0x67, 0xef, 0x73, 0x0e, 0x28, 0xe5, 0xbd, 0xd7, 0xf7, 0x5d, 0xff, 0xb0, 0x88, 0xbd, + 0xd7, 0x9e, 0xd6, 0x5e, 0xf3, 0x5e, 0x7b, 0x1f, 0xeb, 0x86, 0xba, 0xd7, 0x71, 0xec, 0x8d, 0xda, + 0x96, 0xeb, 0xfb, 0xce, 0x86, 0xeb, 0xdb, 0x35, 0x6f, 0x6b, 0xcb, 0x6b, 0x4d, 0x6f, 0xb7, 0xbd, + 0x8e, 0x37, 0x71, 0xad, 0xdf, 0x71, 0x9d, 0x2d, 0x59, 0x27, 0x0a, 0x8f, 0x6c, 0xd4, 0xfc, 0xfa, + 0x45, 0xad, 0x0d, 0x2f, 0x9f, 0xfc, 0xda, 0xa8, 0x35, 0x9e, 0xae, 0x14, 0x33, 0xc5, 0x6a, 0x6a, + 0xc5, 0xd9, 0x72, 0x53, 0xb5, 0x9a, 0xd7, 0x6d, 0x75, 0xd2, 0xcd, 0x86, 0xdb, 0xea, 0x24, 0xc6, + 0x2d, 0xcb, 0xe1, 0x05, 0x76, 0xa3, 0x3e, 0xde, 0x77, 0x73, 0xdf, 0x9d, 0xfb, 0x97, 0x06, 0x1f, + 0x79, 0xf5, 0x8d, 0x7d, 0x89, 0x7d, 0xd6, 0xe0, 0xe5, 0x46, 0xcb, 0x1f, 0x1f, 0xc0, 0xb2, 0xc4, + 0x98, 0x35, 0xdc, 0xf4, 0x7c, 0xdf, 0xf5, 0xc7, 0x07, 0xe9, 0xb7, 0x65, 0xf5, 0x3f, 0xbc, 0x3d, + 0xbe, 0x8f, 0xfe, 0xde, 0x6f, 0x0d, 0x35, 0xdd, 0x4b, 0x6e, 0x73, 0x7c, 0x3f, 0xfd, 0x3c, 0x6c, + 0xed, 0x6f, 0xb4, 0x1a, 0x9d, 0x86, 0xd3, 0xb4, 0xfd, 0x8b, 0x8d, 0x66, 0x73, 0x7c, 0x8c, 0x8a, + 0x0f, 0x59, 0xfb, 0x9a, 0xae, 0x73, 0xc9, 0x6d, 0xdb, 0x34, 0xdc, 0xf8, 0x01, 0x2a, 0x3d, 0x66, + 0x1d, 0xf1, 0xdd, 0x9a, 0xd7, 0xaa, 0x3b, 0xed, 0x1d, 0xdb, 0xa8, 0x4f, 0x52, 0xfd, 0x4d, 0xd6, + 0x75, 0x4d, 0xef, 0xb2, 0xbd, 0xdd, 0x6e, 0x78, 0xed, 0x46, 0x67, 0xc7, 0x86, 0x9a, 0x46, 0xd3, + 0xae, 0x3b, 0x1d, 0x77, 0x3c, 0x41, 0x00, 0xb7, 0x59, 0x37, 0x6c, 0xb7, 0x61, 0x74, 0x58, 0x40, + 0xc7, 0x7d, 0xb8, 0x63, 0xd7, 0x36, 0x9d, 0x8e, 0x0e, 0x75, 0x88, 0xa0, 0x6e, 0xb6, 0xc6, 0x25, + 0xd4, 0x25, 0xaf, 0x51, 0x73, 0x75, 0x88, 0xc3, 0x12, 0xa2, 0xe9, 0xf8, 0x1d, 0xdb, 0xb9, 0xe0, + 0xb4, 0xea, 0x5e, 0xcb, 0xad, 0xdb, 0x1b, 0x80, 0x2c, 0x0e, 0x71, 0x84, 0x20, 0xa6, 0xac, 0x49, + 0x82, 0x08, 0xe6, 0x1b, 0x07, 0x3b, 0x4f, 0xb0, 0x37, 0x58, 0x87, 0xc4, 0x62, 0xb6, 0xdd, 0x96, + 0xd3, 0x84, 0x89, 0xf3, 0x45, 0x5d, 0x47, 0xb5, 0x37, 0x5a, 0x87, 0x61, 0x3b, 0xb7, 0x9b, 0x6e, + 0x47, 0x36, 0xf5, 0x3b, 0x6d, 0xd7, 0xb9, 0x38, 0x3e, 0x4e, 0xd5, 0xcc, 0x1a, 0x81, 0xed, 0xad, + 0x6d, 0x36, 0x5a, 0x1b, 0xe3, 0x37, 0x50, 0x09, 0xa0, 0x1b, 0xba, 0xab, 0xbb, 0x6d, 0x7f, 0xb3, + 0xb1, 0x3d, 0x7e, 0xa3, 0x84, 0x5a, 0x6f, 0xc3, 0x1e, 0xd6, 0x9b, 0x3b, 0xe3, 0xc7, 0xa8, 0xe4, + 0xa0, 0xb5, 0x77, 0xdd, 0x6b, 0x6f, 0x34, 0x2e, 0x61, 0xc3, 0x9b, 0xa8, 0xe8, 0x56, 0xeb, 0x7a, + 0xb9, 0xbd, 0xf5, 0x86, 0xef, 0x5c, 0x68, 0xc2, 0x80, 0xda, 0xd2, 0x6f, 0x97, 0x7b, 0x10, 0x01, + 0xe2, 0xd3, 0xbd, 0x83, 0xea, 0xc7, 0x2d, 0xe6, 0x6f, 0x7a, 0x97, 0x6b, 0x8e, 0xef, 0xda, 0x9b, + 0x6e, 0xdb, 0x43, 0x4a, 0xb9, 0x93, 0x6a, 0x6e, 0xb1, 0x8e, 0x6e, 0x39, 0x9d, 0xda, 0x66, 0x6c, + 0xe7, 0x77, 0x49, 0x4c, 0x84, 0x40, 0x78, 0xd7, 0x53, 0x54, 0xbb, 0x68, 0x1d, 0xda, 0x76, 0xda, + 0x9d, 0x16, 0x20, 0x4a, 0x4e, 0xa1, 0xb3, 0xb3, 0xed, 0x8e, 0xdf, 0x03, 0xb5, 0x63, 0x27, 0xaf, + 0x9d, 0x2e, 0xf1, 0x4a, 0x41, 0xb3, 0x55, 0xa8, 0x4a, 0xee, 0x2b, 0xa5, 0xca, 0xd5, 0x42, 0xb6, + 0x6c, 0x17, 0x8a, 0x85, 0x2c, 0xa2, 0x32, 0xdc, 0x81, 0xdf, 0xc1, 0xd1, 0xef, 0xa5, 0xfe, 0x9f, + 0x60, 0xdd, 0xe8, 0x6f, 0x76, 0x3b, 0x75, 0xef, 0x72, 0xab, 0xe9, 0x5c, 0xee, 0xb8, 0xed, 0xad, + 0x46, 0x0b, 0x6a, 0x3b, 0x0d, 0xe0, 0x91, 0x8e, 0xb3, 0xb5, 0x3d, 0x7e, 0x9f, 0x24, 0x22, 0x83, + 0xca, 0x70, 0x4f, 0x7c, 0xbb, 0xed, 0x6e, 0x39, 0x40, 0xc9, 0x80, 0xcc, 0xe3, 0x12, 0x0f, 0xb8, + 0x6d, 0xd0, 0xba, 0xd3, 0xb8, 0xe4, 0xda, 0x6d, 0xa7, 0x75, 0x71, 0xfc, 0x84, 0x44, 0x73, 0xcd, + 0x69, 0x36, 0x2e, 0xb4, 0x9d, 0x4e, 0xc3, 0x6b, 0x45, 0x9a, 0xdf, 0x2f, 0x77, 0xdd, 0xf7, 0x9a, + 0x9e, 0x1d, 0xe9, 0xe3, 0x01, 0xaa, 0xbe, 0xd3, 0xba, 0x99, 0x57, 0xef, 0xd2, 0xd1, 0x29, 0x89, + 0x52, 0xbd, 0x8f, 0x13, 0x97, 0x4e, 0xf0, 0x7e, 0x16, 0xa9, 0xf6, 0x7e, 0xeb, 0xee, 0x70, 0xed, + 0x6e, 0x5d, 0xfe, 0x3c, 0x35, 0x3a, 0x6a, 0x1d, 0x6c, 0xbb, 0xb5, 0x76, 0xb7, 0xd1, 0xd9, 0x42, + 0x1e, 0xe1, 0xec, 0x3c, 0x23, 0xa7, 0xbd, 0xe9, 0xf8, 0x76, 0xcb, 0xbd, 0x6c, 0xb7, 0xbc, 0x4e, + 0x63, 0xbd, 0x51, 0xa3, 0x8e, 0xfc, 0xf1, 0x59, 0xa8, 0x1e, 0x49, 0x5c, 0x67, 0x1d, 0x68, 0xf8, + 0xc8, 0xb9, 0x1b, 0x5d, 0xd7, 0x76, 0xea, 0x80, 0xdf, 0xf1, 0x39, 0xaa, 0xb8, 0xde, 0xba, 0x16, + 0x28, 0xa6, 0x0b, 0x52, 0x80, 0x0f, 0xb9, 0xdd, 0x74, 0x76, 0xdc, 0xfa, 0xf8, 0x7f, 0x51, 0xfb, + 0x12, 0xc6, 0x85, 0x01, 0xf6, 0x73, 0x04, 0x76, 0xbb, 0x75, 0x0c, 0x77, 0x77, 0xa7, 0x37, 0xdc, + 0x82, 0x94, 0x12, 0x62, 0x2c, 0x5c, 0xae, 0x01, 0x90, 0x92, 0xe3, 0xe9, 0x5d, 0xa0, 0xf4, 0x34, + 0xc1, 0x96, 0x08, 0x6c, 0xd2, 0x9a, 0xa8, 0x75, 0xdb, 0x40, 0x4a, 0xcd, 0x26, 0xa7, 0x74, 0x90, + 0x26, 0xcd, 0xa6, 0xdb, 0xda, 0x70, 0x91, 0xe6, 0xd3, 0x92, 0x0a, 0xb0, 0x8d, 0x8d, 0x34, 0x64, + 0x6f, 0x7b, 0x8d, 0x56, 0xc7, 0x1f, 0xcf, 0x48, 0xc1, 0x27, 0x69, 0x70, 0xbd, 0xe9, 0x6c, 0xf8, + 0xe3, 0x59, 0x2a, 0x06, 0x0c, 0x05, 0x0d, 0x38, 0x66, 0x97, 0xa9, 0xe2, 0x6e, 0xeb, 0x56, 0x1a, + 0xbd, 0x6d, 0x5f, 0x70, 0x37, 0x9d, 0x4b, 0x40, 0x7b, 0x20, 0x5b, 0x9e, 0x6c, 0xb7, 0xba, 0x5b, + 0x36, 0x09, 0x9a, 0xb6, 0xbb, 0xed, 0xb5, 0x3b, 0xe3, 0x2b, 0x04, 0x7c, 0x97, 0x75, 0x4b, 0x04, + 0xb8, 0xe6, 0xb5, 0x5d, 0x03, 0xf4, 0x34, 0x82, 0x4e, 0xbe, 0xbb, 0xcf, 0x4a, 0x08, 0x81, 0x8f, + 0xfc, 0xb3, 0xb3, 0xea, 0x6e, 0x5d, 0x70, 0xdb, 0x89, 0x19, 0x6b, 0x9f, 0x64, 0x15, 0xe2, 0xb1, + 0xbe, 0xab, 0xe5, 0x31, 0x90, 0x34, 0x0d, 0x54, 0x40, 0x20, 0x92, 0xc6, 0xfb, 0x69, 0x6f, 0x6f, + 0x44, 0x72, 0xd9, 0x40, 0x72, 0xda, 0x06, 0x1a, 0x82, 0xaa, 0x3a, 0x29, 0x86, 0x01, 0x50, 0x1e, + 0xfd, 0xac, 0x2f, 0x5c, 0x4d, 0xdc, 0x36, 0x3e, 0xa4, 0xaa, 0x01, 0xcb, 0x7a, 0xf5, 0xba, 0xd3, + 0x40, 0xb1, 0x70, 0x01, 0x68, 0xcf, 0xf1, 0x2f, 0x8e, 0x0f, 0xd3, 0x1a, 0xbe, 0xba, 0xc7, 0xda, + 0xa7, 0xaf, 0x21, 0x71, 0xc4, 0x1a, 0xe1, 0xa4, 0x20, 0xd4, 0xd4, 0xa0, 0x50, 0x53, 0x20, 0xf4, + 0xb8, 0x68, 0xc4, 0x0a, 0x9c, 0xdd, 0x30, 0x4a, 0xcb, 0x2d, 0x5a, 0x32, 0x14, 0xa1, 0xfe, 0x1a, + 0xe0, 0x65, 0x24, 0x68, 0xb7, 0xc4, 0x54, 0x39, 0x75, 0x0d, 0x71, 0x59, 0x31, 0x2c, 0x30, 0xa1, + 0x0f, 0x38, 0x5d, 0xc1, 0xaa, 0x64, 0xff, 0x5a, 0x0e, 0x05, 0xbf, 0xbb, 0xbe, 0xee, 0xd6, 0x88, + 0x74, 0xa0, 0x45, 0x1b, 0xc5, 0x36, 0x09, 0xb5, 0x2d, 0xe7, 0xa2, 0x5c, 0xe0, 0xf8, 0x1e, 0x29, + 0x49, 0xda, 0xce, 0xe5, 0xde, 0x50, 0x37, 0x13, 0xd4, 0x84, 0x95, 0x70, 0x3a, 0x1d, 0x77, 0x6b, + 0xbb, 0xc3, 0x21, 0x79, 0xdd, 0x2d, 0x54, 0x77, 0xad, 0x35, 0x2a, 0xeb, 0x80, 0x12, 0xc6, 0x27, + 0x65, 0x21, 0x75, 0xb5, 0xd1, 0xf6, 0xba, 0xdb, 0xfe, 0xf8, 0x68, 0xac, 0x6e, 0xd4, 0x14, 0xf9, + 0xb5, 0x04, 0x70, 0x02, 0x10, 0x41, 0xb2, 0x97, 0xf6, 0xfb, 0x30, 0xad, 0xd2, 0x9a, 0x5e, 0xc5, + 0x22, 0xda, 0xe6, 0x83, 0xab, 0xa9, 0x6a, 0xfa, 0xb4, 0x5d, 0x3d, 0x5f, 0xca, 0xda, 0xe9, 0x54, + 0x65, 0x2d, 0x95, 0x4f, 0x2c, 0x59, 0x63, 0x17, 0x3c, 0xd4, 0x03, 0xeb, 0xc0, 0xe8, 0x5d, 0x50, + 0x5c, 0xa4, 0xfc, 0xc6, 0x4e, 0x26, 0xa6, 0x11, 0x33, 0x4b, 0x5e, 0x27, 0xa3, 0x6a, 0x92, 0x47, + 0x96, 0x8a, 0x55, 0x3b, 0x93, 0x5b, 0x5e, 0xce, 0xa5, 0xd7, 0xf2, 0xd5, 0xf3, 0x76, 0x29, 0x55, + 0xa9, 0xe4, 0xce, 0x66, 0x13, 0x07, 0xac, 0x3d, 0xc4, 0x60, 0x30, 0x8f, 0xeb, 0xae, 0xac, 0x26, + 0xc6, 0x7b, 0x80, 0x68, 0xab, 0x39, 0x2a, 0x79, 0x58, 0x47, 0xe7, 0x96, 0xf3, 0x30, 0x8a, 0x3d, + 0x60, 0x4d, 0x90, 0x39, 0xdd, 0x0e, 0xec, 0xea, 0x04, 0x81, 0x1d, 0xb1, 0xc6, 0x08, 0xac, 0x09, + 0x75, 0x5d, 0x34, 0x83, 0xc6, 0xaf, 0x0f, 0xca, 0xb7, 0x01, 0x5b, 0xee, 0xba, 0xdb, 0x76, 0x5b, + 0x35, 0xa9, 0xfd, 0x6e, 0xb3, 0xf6, 0x70, 0x6a, 0xf1, 0x41, 0xb1, 0x0e, 0xdc, 0x39, 0x1a, 0xa2, + 0x03, 0xc1, 0x3c, 0xc0, 0xdb, 0x1e, 0xa8, 0x72, 0x7b, 0xa3, 0xdb, 0x68, 0xd6, 0x71, 0x4e, 0xc7, + 0x24, 0xcb, 0x73, 0xc3, 0x8c, 0x57, 0xf8, 0xa0, 0x76, 0x07, 0xae, 0x42, 0x9f, 0xdc, 0x2a, 0xf5, + 0x35, 0x4c, 0x5d, 0x88, 0x84, 0xdb, 0x54, 0x11, 0xac, 0x8b, 0x17, 0x3d, 0x41, 0x2c, 0xfb, 0x90, + 0xc3, 0x49, 0x0f, 0x5a, 0x22, 0x09, 0x93, 0x19, 0xe3, 0x83, 0x6e, 0x1e, 0x80, 0x7d, 0xd9, 0x33, + 0x9d, 0xcd, 0xe2, 0x6f, 0x54, 0xe2, 0x34, 0x41, 0xb0, 0x00, 0xec, 0x5f, 0x04, 0xa9, 0x04, 0xa3, + 0x3d, 0xb9, 0x0b, 0x4a, 0xce, 0x27, 0x55, 0x3d, 0x02, 0xf2, 0x63, 0x9f, 0x8f, 0xa2, 0xbd, 0xd1, + 0xba, 0xd4, 0x40, 0x64, 0xdd, 0x15, 0xb3, 0xd6, 0x1c, 0xd5, 0x21, 0x28, 0x28, 0x83, 0x4b, 0x0a, + 0x74, 0xaa, 0x37, 0x68, 0x44, 0xe4, 0xdd, 0x4d, 0xdc, 0x7b, 0xdc, 0x1a, 0x22, 0xf6, 0x49, 0x0c, + 0x5b, 0xc0, 0x40, 0xec, 0x1a, 0x58, 0xd7, 0xfe, 0xe5, 0x5c, 0x21, 0x93, 0x2b, 0xac, 0xd8, 0x44, + 0x73, 0x0c, 0xed, 0xcb, 0x91, 0x5c, 0x41, 0xfc, 0xea, 0x9f, 0x7c, 0x7d, 0xbf, 0x29, 0xb3, 0x44, + 0xff, 0xc0, 0xf5, 0x44, 0xf2, 0x31, 0x5c, 0x0f, 0xab, 0x31, 0xb8, 0x1e, 0x58, 0x44, 0x14, 0xb5, + 0x00, 0x4b, 0x64, 0xb6, 0xee, 0x4d, 0x1c, 0x0f, 0x36, 0x77, 0x90, 0x56, 0x71, 0x53, 0xcc, 0x2a, + 0xa6, 0xf5, 0x8d, 0xd6, 0x88, 0x77, 0x88, 0xf0, 0x0f, 0x7a, 0xcc, 0xd8, 0x4b, 0x14, 0x19, 0x5d, + 0x9f, 0x64, 0xc6, 0x08, 0x8a, 0x46, 0x47, 0x8a, 0xc6, 0x3d, 0x54, 0x02, 0x82, 0x86, 0xe3, 0xcd, + 0xde, 0x80, 0x2e, 0x46, 0x68, 0x6a, 0x60, 0x3c, 0x83, 0x0e, 0x69, 0xb4, 0xdc, 0xf1, 0xbd, 0xd8, + 0xe5, 0xc4, 0xa2, 0x35, 0xaa, 0x0f, 0x09, 0x96, 0x36, 0x4d, 0xb9, 0x8f, 0xa6, 0x0c, 0x5d, 0xfa, + 0x72, 0x06, 0x7c, 0x65, 0xba, 0xfc, 0x45, 0xc9, 0x35, 0x32, 0xf9, 0xe2, 0x00, 0x5b, 0x79, 0xef, + 0xc2, 0x85, 0xff, 0x7c, 0x6c, 0x69, 0xa3, 0x4c, 0xd3, 0xdf, 0x62, 0xea, 0xc0, 0x54, 0xb5, 0xae, + 0xdf, 0xf1, 0xb8, 0x36, 0x95, 0x48, 0x1b, 0x0c, 0x61, 0x61, 0x98, 0x86, 0x04, 0x3d, 0xa8, 0xc3, + 0xd6, 0xda, 0x35, 0x42, 0xd9, 0x30, 0x99, 0xc3, 0x5a, 0x45, 0x60, 0x9c, 0x21, 0xf6, 0xf6, 0x4c, + 0xdc, 0x6b, 0x8d, 0xea, 0x43, 0x5e, 0x01, 0x5b, 0x93, 0x7f, 0xde, 0x07, 0xee, 0x0e, 0xce, 0x99, + 0x7b, 0x38, 0xa7, 0x9d, 0x76, 0xfd, 0xb2, 0xd3, 0x76, 0x2b, 0xdb, 0x6e, 0xcd, 0x47, 0xc1, 0xdb, + 0xf4, 0x36, 0xc0, 0x84, 0x69, 0xc2, 0x86, 0x7a, 0x35, 0x70, 0x94, 0x3c, 0x58, 0x6c, 0x9f, 0xb2, + 0xca, 0xb7, 0xbb, 0x76, 0x6d, 0xa7, 0xd6, 0x44, 0xbb, 0xc0, 0x6d, 0x0b, 0x4b, 0x5f, 0x60, 0x0c, + 0xaa, 0x3b, 0xe0, 0x93, 0x41, 0xc3, 0xcd, 0x1d, 0x9f, 0x7a, 0x00, 0x5c, 0x79, 0xed, 0x1d, 0xc2, + 0xdd, 0x30, 0xba, 0x37, 0xb0, 0x49, 0xa7, 0x1e, 0x40, 0x3d, 0x66, 0x7b, 0x5c, 0xc5, 0x8c, 0xe0, + 0x78, 0xdd, 0xed, 0xa6, 0xe7, 0x80, 0x26, 0x70, 0xc1, 0x40, 0x01, 0x09, 0x00, 0x53, 0x12, 0x38, + 0x42, 0xbb, 0x80, 0x84, 0x11, 0xda, 0x55, 0xf6, 0xa6, 0xe7, 0x77, 0x38, 0x51, 0x4d, 0x7e, 0x60, + 0xc0, 0xda, 0x4f, 0x2b, 0xa8, 0x80, 0x07, 0x81, 0x2e, 0x1b, 0xae, 0x92, 0x4b, 0x47, 0x85, 0x60, + 0xdc, 0x52, 0xe7, 0x12, 0x47, 0x16, 0x4d, 0x10, 0xd5, 0xd9, 0x1e, 0x6e, 0x21, 0x70, 0x9d, 0x37, + 0x7a, 0xf2, 0xf0, 0xb4, 0xd1, 0xcb, 0x74, 0x89, 0x6a, 0xc1, 0x40, 0x1c, 0xa3, 0xa6, 0xe0, 0xdc, + 0x75, 0x1c, 0x90, 0x83, 0x72, 0xb3, 0xaf, 0x0f, 0x81, 0xe3, 0x1f, 0x39, 0x01, 0x33, 0x71, 0xde, + 0x1a, 0x56, 0xcd, 0x07, 0x11, 0xe1, 0xc2, 0x7c, 0xd8, 0x4f, 0x7a, 0xc1, 0x5e, 0x49, 0xdb, 0xd5, + 0x6c, 0x6a, 0x35, 0x79, 0x44, 0xff, 0x65, 0xaf, 0x14, 0x8b, 0x19, 0x7b, 0x65, 0xed, 0x7c, 0x45, + 0x6d, 0x5a, 0x3f, 0x6d, 0x1a, 0xfc, 0x42, 0xeb, 0x8a, 0x53, 0xdd, 0xc4, 0xa7, 0xfb, 0xac, 0x7d, + 0xfa, 0x58, 0xb8, 0x36, 0x45, 0x08, 0x62, 0x6d, 0x40, 0xae, 0x38, 0xe8, 0x09, 0x6e, 0xf3, 0x08, + 0x9f, 0x54, 0x14, 0x9e, 0x14, 0x85, 0x5c, 0xa9, 0x67, 0xb9, 0x79, 0x86, 0x9e, 0x97, 0xe7, 0x37, + 0xb8, 0xa5, 0x3a, 0x44, 0xeb, 0xbb, 0x7b, 0x97, 0xf5, 0x09, 0xdc, 0x94, 0x64, 0x13, 0x14, 0x03, + 0x1c, 0x49, 0x9c, 0x7a, 0xf7, 0x9b, 0x08, 0x27, 0x5d, 0x3f, 0x71, 0x87, 0x75, 0x20, 0xdc, 0x6c, + 0xaf, 0xd5, 0xf7, 0x30, 0x61, 0xa6, 0x1f, 0xff, 0xdc, 0xa1, 0xd9, 0xf7, 0x4f, 0xfe, 0x73, 0x9f, + 0x75, 0x20, 0xbd, 0xea, 0x6f, 0xe4, 0xc9, 0x25, 0xe4, 0x92, 0x11, 0x26, 0xdf, 0x44, 0xaa, 0x16, + 0xee, 0x0a, 0x27, 0xc1, 0x05, 0x61, 0xa5, 0xf0, 0xb2, 0x7e, 0xc2, 0xf0, 0x01, 0x81, 0x61, 0x28, + 0xe7, 0x26, 0xc9, 0x51, 0xfe, 0x3b, 0xb5, 0x9a, 0x2d, 0xaf, 0xe5, 0xb3, 0x15, 0xbb, 0x52, 0x4d, + 0x55, 0xb3, 0x76, 0xae, 0x90, 0xab, 0x22, 0x49, 0x09, 0xb7, 0xb3, 0x0e, 0xbe, 0x65, 0x0d, 0x2c, + 0x10, 0x42, 0xd5, 0x08, 0xba, 0x0c, 0xeb, 0x8d, 0x36, 0x18, 0x8a, 0x17, 0x9a, 0x9e, 0x57, 0xb7, + 0x37, 0x9d, 0x6d, 0xd0, 0x15, 0x50, 0x3b, 0x28, 0xcc, 0xb9, 0xc3, 0xa0, 0x76, 0x6b, 0xc0, 0x29, + 0xdc, 0x60, 0x01, 0xdd, 0xe1, 0x83, 0x86, 0xf7, 0x89, 0xd6, 0xc8, 0xc4, 0x07, 0xcb, 0xcc, 0x47, + 0xd5, 0x0c, 0xfc, 0xd0, 0x82, 0x7e, 0x05, 0xa1, 0x3e, 0x7f, 0xd8, 0x62, 0x69, 0x25, 0x1e, 0x04, + 0x7f, 0x32, 0xab, 0x5f, 0x88, 0x9f, 0x61, 0x21, 0x7e, 0x00, 0x97, 0xd2, 0x6d, 0xec, 0x17, 0x2e, + 0x0a, 0x27, 0xa1, 0x81, 0xff, 0x27, 0x24, 0x34, 0x2c, 0x49, 0xc8, 0x6f, 0x7a, 0x1d, 0x61, 0x75, + 0x31, 0xcd, 0x38, 0xdc, 0x27, 0x05, 0xd0, 0x96, 0xdb, 0x71, 0x6c, 0x3d, 0x30, 0x71, 0x00, 0xc5, + 0x1b, 0x94, 0x3d, 0xbc, 0x2d, 0x42, 0x12, 0xb8, 0x30, 0x5e, 0x60, 0x3b, 0x20, 0x23, 0xea, 0x80, + 0x10, 0x1e, 0x95, 0xf8, 0x2f, 0xd6, 0x7e, 0x81, 0x47, 0x21, 0xed, 0x99, 0xb0, 0x10, 0x69, 0xb1, + 0x6a, 0x17, 0xbb, 0xbe, 0xdd, 0x49, 0x32, 0x9a, 0x6f, 0x3e, 0x9b, 0x3a, 0x2b, 0xed, 0x65, 0x10, + 0x8a, 0xa2, 0x35, 0x2a, 0x6e, 0x24, 0xc0, 0x1b, 0xe4, 0xf8, 0xe0, 0x4f, 0x00, 0x02, 0x9b, 0xe3, + 0x07, 0x95, 0x67, 0xd0, 0x6e, 0xfc, 0x92, 0x0b, 0xbb, 0xb5, 0x0e, 0xec, 0x58, 0x77, 0x1f, 0x16, + 0x41, 0x0d, 0xf0, 0x31, 0x94, 0x1d, 0x24, 0x51, 0x77, 0x88, 0x2c, 0x8b, 0x5e, 0x0e, 0xf3, 0xe1, + 0xab, 0x35, 0xe6, 0x61, 0x4c, 0xb7, 0x65, 0xf6, 0x7c, 0x84, 0x7a, 0x9e, 0xb3, 0x2c, 0x52, 0x31, + 0xe4, 0x1c, 0x91, 0xe1, 0x76, 0xd5, 0x5b, 0x03, 0xd3, 0x6d, 0xb9, 0x0f, 0xa3, 0x3d, 0x5f, 0xb3, + 0x2f, 0x80, 0xd9, 0x05, 0x02, 0x4d, 0x98, 0x75, 0x20, 0xff, 0x42, 0x35, 0xb8, 0x85, 0x47, 0x69, + 0x0b, 0x7f, 0xce, 0xb2, 0x00, 0xf1, 0x17, 0xbc, 0x56, 0xd7, 0x27, 0x23, 0x0d, 0x79, 0xf4, 0xae, + 0xe9, 0x30, 0x3d, 0x45, 0x0a, 0x1e, 0x2a, 0x2d, 0x61, 0x13, 0x64, 0x20, 0xf4, 0x7a, 0xd1, 0x45, + 0x03, 0x23, 0x90, 0x82, 0x22, 0x07, 0x91, 0x4b, 0x6b, 0x30, 0x42, 0xdb, 0xd9, 0x72, 0x5a, 0x64, + 0xa2, 0x8d, 0x90, 0x6f, 0xa8, 0x69, 0x17, 0x10, 0xfb, 0xf5, 0x6e, 0xad, 0x43, 0xae, 0x01, 0x19, + 0x6b, 0x13, 0xab, 0xd6, 0x75, 0xbd, 0xc6, 0x00, 0x2a, 0x53, 0xae, 0x12, 0x51, 0x99, 0x9c, 0x30, + 0x67, 0x6c, 0xa4, 0x32, 0xdf, 0xeb, 0xb6, 0x6b, 0xae, 0x7d, 0xd1, 0xe5, 0x8a, 0x60, 0x70, 0xf2, + 0xd3, 0xfd, 0xd6, 0xc1, 0x34, 0xf5, 0x55, 0x05, 0x44, 0x66, 0x80, 0xbe, 0x1a, 0x4d, 0x1f, 0x27, + 0x46, 0x6a, 0xca, 0x54, 0x5d, 0x54, 0xd4, 0x71, 0x36, 0x84, 0xfe, 0xd5, 0x6c, 0x8f, 0x41, 0x29, + 0x74, 0xa8, 0x00, 0x74, 0x96, 0x27, 0x04, 0x3f, 0x10, 0x17, 0x15, 0x5d, 0xc0, 0x68, 0x0c, 0x95, + 0x0f, 0x53, 0x39, 0xec, 0x81, 0x28, 0x6f, 0x21, 0x71, 0x50, 0xcd, 0x1e, 0xaa, 0x01, 0x1b, 0x8d, + 0x6a, 0x64, 0xc8, 0x89, 0xd4, 0x2a, 0x19, 0x2a, 0xdc, 0x98, 0xa5, 0x29, 0xed, 0xa5, 0x09, 0xa0, + 0xe4, 0xa5, 0x32, 0x9c, 0x93, 0x25, 0x67, 0xa9, 0x6c, 0xde, 0x51, 0x19, 0x8c, 0xe2, 0x25, 0x34, + 0xc6, 0x3e, 0xa9, 0xcb, 0x78, 0x59, 0x30, 0xad, 0xfd, 0x54, 0x71, 0xd4, 0x3a, 0x28, 0x2b, 0x82, + 0x79, 0x8d, 0x51, 0x15, 0x20, 0x97, 0xc2, 0x16, 0x07, 0xa4, 0x30, 0xd7, 0xb7, 0x93, 0xd1, 0x76, + 0x72, 0xa5, 0xba, 0xe9, 0x6d, 0x71, 0x97, 0x9d, 0xd8, 0x66, 0x64, 0xf2, 0x31, 0xd4, 0xf0, 0x1c, + 0xc3, 0x20, 0x8c, 0xeb, 0x65, 0x17, 0x79, 0x57, 0x22, 0x1a, 0xf0, 0x03, 0x66, 0xc7, 0x96, 0xc6, + 0x52, 0xfd, 0x92, 0xd7, 0xa0, 0x2b, 0xbf, 0xbb, 0xbd, 0xdd, 0xdc, 0x01, 0xdb, 0x03, 0xe5, 0x2b, + 0x17, 0x8d, 0x18, 0xae, 0xf4, 0x49, 0xac, 0xd7, 0xed, 0x7a, 0xdb, 0xdb, 0x16, 0x32, 0x31, 0x61, + 0x04, 0x46, 0x87, 0x64, 0x10, 0x14, 0x6c, 0x40, 0x30, 0xe4, 0x84, 0x93, 0xda, 0xb6, 0x26, 0xf8, + 0x3c, 0x96, 0xda, 0xa0, 0xe2, 0x6b, 0xe0, 0x88, 0xa7, 0x39, 0x7f, 0xe7, 0x5a, 0xeb, 0x1e, 0xf6, + 0x20, 0xd8, 0x5d, 0x85, 0x56, 0x71, 0x41, 0xd4, 0x67, 0x7b, 0x87, 0x9c, 0x66, 0xa1, 0x0f, 0x61, + 0xed, 0xe0, 0x95, 0xd6, 0xda, 0x8d, 0x6d, 0x14, 0x17, 0x82, 0x18, 0x60, 0x5e, 0xd2, 0x85, 0xe1, + 0xb0, 0x38, 0xaf, 0xbd, 0x93, 0x2f, 0xbc, 0x4e, 0x39, 0xc6, 0x34, 0x34, 0x1a, 0x7d, 0x5c, 0x91, + 0x84, 0x8c, 0xbe, 0xc9, 0xc0, 0x98, 0xeb, 0x27, 0xde, 0x3a, 0x18, 0x61, 0xa5, 0xc4, 0x1d, 0x18, + 0x93, 0x5d, 0xef, 0xd8, 0x12, 0x70, 0x4f, 0x2f, 0x40, 0xc3, 0xcb, 0x1e, 0x15, 0x06, 0x0f, 0x18, + 0x95, 0xed, 0x4b, 0xbc, 0x88, 0x2c, 0xbc, 0x64, 0xdf, 0x71, 0xa5, 0xbb, 0xd1, 0xcf, 0x16, 0x6a, + 0x1a, 0xa5, 0x1c, 0x98, 0x9a, 0xe8, 0xb3, 0x49, 0x8f, 0xc2, 0x22, 0x9f, 0x5c, 0xf9, 0xdf, 0x83, + 0xa6, 0xff, 0x4d, 0x03, 0x6b, 0xfe, 0x37, 0xca, 0x4d, 0xa1, 0x77, 0x86, 0x08, 0x35, 0x0f, 0x58, + 0x16, 0x5f, 0x32, 0x31, 0xe7, 0x3e, 0x6a, 0x7d, 0x9d, 0xd9, 0x9a, 0x93, 0x07, 0x8a, 0xbf, 0x3d, + 0xb9, 0xc2, 0xd9, 0x54, 0x3e, 0x97, 0x41, 0xdc, 0x3b, 0x4d, 0x34, 0xe5, 0x6b, 0x9b, 0xae, 0x03, + 0xca, 0x6d, 0x3f, 0xed, 0x33, 0xd0, 0xcb, 0x7a, 0xa3, 0xd9, 0xb4, 0x2f, 0x37, 0x3a, 0x9b, 0xc0, + 0xdb, 0x50, 0x3e, 0x16, 0xd8, 0xf1, 0x1d, 0x10, 0x90, 0xb4, 0x92, 0x03, 0x54, 0x26, 0x17, 0x47, + 0x1c, 0xc3, 0x68, 0x2a, 0x77, 0x5a, 0xfb, 0x88, 0xb9, 0xea, 0x9c, 0xfc, 0x80, 0x42, 0x11, 0x83, + 0x89, 0xe9, 0xa8, 0x04, 0x00, 0x34, 0x74, 0xba, 0x1d, 0xa0, 0x1f, 0xb0, 0x1c, 0x9b, 0x68, 0x78, + 0xb6, 0x84, 0xb0, 0x47, 0xfe, 0x04, 0x21, 0x82, 0x9d, 0xea, 0xce, 0x3b, 0x88, 0x4e, 0xad, 0x58, + 0x9a, 0xd7, 0x87, 0x84, 0x7e, 0xd8, 0x2f, 0x70, 0xcf, 0x03, 0x29, 0x3c, 0x86, 0x8d, 0xf8, 0x37, + 0x2d, 0x88, 0x23, 0x3f, 0xb3, 0x05, 0x01, 0xe8, 0xc0, 0xf8, 0x93, 0x0f, 0xd6, 0x32, 0x80, 0xa2, + 0x71, 0x7c, 0x9d, 0x64, 0xfa, 0x20, 0x00, 0x21, 0x1c, 0xf2, 0x69, 0xd8, 0x97, 0x2d, 0x7b, 0xbb, + 0x51, 0xbb, 0x48, 0x0a, 0x4e, 0xa9, 0x8b, 0xf4, 0xaa, 0x5d, 0xca, 0xa5, 0xcf, 0x24, 0xc7, 0xe4, + 0xaf, 0x72, 0xaa, 0x90, 0x29, 0xae, 0x1a, 0x56, 0xec, 0x31, 0x12, 0x01, 0xc7, 0x2c, 0xc6, 0xb7, + 0x44, 0x8c, 0x27, 0x03, 0xd7, 0x23, 0xc9, 0xc1, 0x4e, 0xbb, 0xeb, 0x82, 0xb6, 0x0b, 0x47, 0x23, + 0x6e, 0xeb, 0x19, 0x8d, 0xb8, 0x36, 0x14, 0x8d, 0x38, 0x9d, 0x2a, 0x67, 0x40, 0x91, 0xef, 0x23, + 0x74, 0x00, 0xaa, 0x7c, 0xc4, 0xd3, 0x13, 0xa8, 0x39, 0x9b, 0x96, 0x87, 0x21, 0x67, 0x79, 0x79, + 0xf2, 0x10, 0x22, 0xc3, 0x06, 0x0d, 0x5e, 0xc9, 0x15, 0x0b, 0x76, 0x7a, 0xad, 0x5c, 0xce, 0x16, + 0xaa, 0x89, 0x19, 0xeb, 0x10, 0x97, 0x0b, 0x6d, 0x12, 0x31, 0x6a, 0x93, 0x6f, 0xa7, 0x4d, 0x3e, + 0x3a, 0xdd, 0x53, 0x08, 0x91, 0x3d, 0x02, 0x16, 0x13, 0x6a, 0x85, 0x3b, 0x88, 0x4e, 0xee, 0xb3, + 0xae, 0xc5, 0x95, 0xa0, 0xcd, 0xa2, 0x2f, 0xe7, 0x2e, 0x72, 0xe2, 0x63, 0x96, 0x83, 0x5d, 0xf0, + 0xa0, 0x2a, 0x20, 0x6b, 0x4a, 0x9c, 0x50, 0x1c, 0x96, 0x87, 0x09, 0x64, 0xd5, 0xd8, 0x6d, 0xa7, + 0xde, 0x70, 0xc0, 0x9d, 0xb8, 0x5b, 0x6e, 0xfe, 0x8d, 0x56, 0xc2, 0x84, 0xa8, 0x37, 0xda, 0x3c, + 0x96, 0x4e, 0xd5, 0x78, 0x02, 0x83, 0xae, 0x88, 0xa4, 0xa5, 0x7b, 0xa5, 0xe0, 0x05, 0x5a, 0x6a, + 0x80, 0xcb, 0x43, 0xdc, 0x34, 0x2d, 0x9d, 0x5e, 0xd1, 0xbb, 0x2d, 0x2a, 0xe9, 0x2c, 0xe8, 0xbe, + 0xc0, 0x3a, 0x69, 0xbb, 0x46, 0xcd, 0x71, 0x19, 0x63, 0x01, 0xfb, 0x12, 0xa8, 0x15, 0x8c, 0x4b, + 0x14, 0xb1, 0x75, 0x11, 0x1f, 0xa7, 0x91, 0xa1, 0x5c, 0x5a, 0x59, 0x27, 0x05, 0xf4, 0x1e, 0xd8, + 0x7d, 0x3c, 0xb0, 0xa1, 0x08, 0xf9, 0x48, 0x72, 0x68, 0xdd, 0x69, 0xfa, 0x6e, 0x62, 0xd6, 0xda, + 0x4f, 0xa7, 0x5f, 0x9d, 0x4b, 0x80, 0x71, 0x30, 0xb0, 0xc7, 0x9f, 0x48, 0xbb, 0x76, 0x90, 0x33, + 0x75, 0x06, 0xaa, 0xaa, 0x67, 0x33, 0x58, 0x91, 0x1c, 0xd3, 0x4a, 0xec, 0x13, 0xc7, 0x29, 0x42, + 0xaf, 0xe9, 0x7a, 0x62, 0xdd, 0x53, 0x84, 0xff, 0xc0, 0xf9, 0xc4, 0x20, 0x10, 0x31, 0xf0, 0x0c, + 0x55, 0x80, 0x82, 0x12, 0x15, 0xda, 0xb6, 0xcc, 0xd2, 0xfc, 0x46, 0xad, 0x01, 0x90, 0xc0, 0x22, + 0x9c, 0x3d, 0x6f, 0x1d, 0xb9, 0x20, 0xa5, 0xbc, 0xad, 0xe4, 0x3a, 0xc8, 0xf9, 0xf1, 0xa4, 0xf4, + 0x9e, 0x7a, 0xab, 0x82, 0x63, 0xd6, 0x11, 0x6e, 0x7e, 0x2b, 0xbb, 0x90, 0xb4, 0x00, 0xec, 0xc1, + 0xbc, 0x72, 0x2e, 0x38, 0x32, 0x1b, 0x32, 0x42, 0x4e, 0x28, 0x0b, 0xc2, 0x0e, 0x14, 0x10, 0x1f, + 0x01, 0x32, 0x1a, 0x73, 0x1f, 0xee, 0xb4, 0x1d, 0x5b, 0x9e, 0xf1, 0x8d, 0x2f, 0xd0, 0xe8, 0x21, + 0xe9, 0x97, 0xce, 0x22, 0x10, 0x78, 0x1c, 0x89, 0x5b, 0x84, 0xdb, 0x82, 0xf8, 0xa0, 0x03, 0x82, + 0xd1, 0x93, 0x63, 0xa6, 0x1f, 0xd4, 0xd3, 0x37, 0x48, 0xd1, 0x88, 0x0b, 0xd6, 0x7e, 0xce, 0xb4, + 0x5e, 0xb7, 0x03, 0x16, 0x84, 0x4b, 0xb1, 0xeb, 0x31, 0xe8, 0x24, 0x4b, 0x71, 0xc4, 0x22, 0x2f, + 0x4d, 0x5e, 0x77, 0xd1, 0x36, 0x0a, 0xec, 0xb5, 0xd6, 0xc5, 0x96, 0x77, 0xb9, 0x15, 0xe7, 0x3c, + 0xa4, 0xa5, 0xe0, 0x0d, 0x85, 0x0e, 0x32, 0x24, 0x13, 0x7a, 0xc5, 0xbb, 0xb2, 0x66, 0xbc, 0x0b, + 0xc4, 0xa3, 0xdc, 0xd0, 0x46, 0xcb, 0x96, 0x8e, 0xef, 0x8a, 0x14, 0x9d, 0x6a, 0xb3, 0x1f, 0x56, + 0x75, 0x14, 0x1c, 0x8f, 0x44, 0xc1, 0x73, 0x57, 0x6b, 0x38, 0xdf, 0x6e, 0x1d, 0x03, 0x6a, 0x20, + 0x3f, 0x5d, 0x84, 0xb5, 0x3d, 0xdb, 0x14, 0xc2, 0x4f, 0xa2, 0x01, 0x32, 0x96, 0x75, 0xa9, 0xe1, + 0x37, 0x2e, 0x34, 0x9a, 0xb8, 0x6d, 0x67, 0xa8, 0xfb, 0x43, 0xd3, 0x6a, 0x6f, 0xce, 0xaa, 0xba, + 0xe4, 0x44, 0x4c, 0xa1, 0x5d, 0xea, 0x5e, 0x68, 0x36, 0x6a, 0x71, 0xc1, 0x92, 0x3c, 0xa9, 0x5d, + 0x98, 0x86, 0x5e, 0xe1, 0x80, 0x4a, 0x81, 0x5a, 0x17, 0x99, 0xcd, 0x26, 0xa5, 0x38, 0xbe, 0x4a, + 0xe8, 0x05, 0x56, 0x10, 0x87, 0x32, 0x01, 0x65, 0x15, 0x14, 0x93, 0xf2, 0x1a, 0x89, 0xf8, 0xa2, + 0x8a, 0x7f, 0xc4, 0x86, 0x61, 0x4a, 0x18, 0x86, 0x41, 0x3b, 0x1a, 0x8f, 0x50, 0x1b, 0x1e, 0x78, + 0x3d, 0xa2, 0x4b, 0x22, 0x0c, 0xa0, 0xc1, 0x07, 0x61, 0x6b, 0x06, 0x0d, 0x00, 0x41, 0x32, 0x80, + 0x9c, 0x76, 0x03, 0x78, 0xb0, 0x4c, 0x3b, 0x7b, 0xa7, 0x75, 0xb3, 0x3e, 0x00, 0x9a, 0xfd, 0xca, + 0x89, 0x69, 0xbb, 0xe0, 0xc3, 0x83, 0x49, 0x5e, 0xa1, 0xc9, 0x23, 0xae, 0xe5, 0xe4, 0x9b, 0x2e, + 0x39, 0x51, 0x41, 0x00, 0x8e, 0x2c, 0xc1, 0x2a, 0x4d, 0xf9, 0x8c, 0x75, 0x73, 0x6f, 0xb8, 0xda, + 0x26, 0x9e, 0xf4, 0x8e, 0xaf, 0xd1, 0x0e, 0x1c, 0x99, 0xae, 0x48, 0x88, 0x92, 0x00, 0xa0, 0x3d, + 0xde, 0xbb, 0x56, 0xc8, 0x64, 0x97, 0x73, 0x85, 0x6c, 0x26, 0x51, 0xb4, 0x6e, 0x13, 0x9d, 0xb5, + 0xa0, 0x9b, 0xde, 0x1d, 0x9e, 0xbd, 0xda, 0x0e, 0xd1, 0x28, 0x16, 0xba, 0x58, 0x86, 0xf8, 0xcf, + 0xd1, 0xb4, 0x0b, 0xd6, 0xfe, 0x6d, 0x07, 0x96, 0x0f, 0x83, 0x74, 0x48, 0xe7, 0x3d, 0x24, 0xba, + 0x54, 0xe2, 0xac, 0x84, 0xd5, 0x15, 0x5e, 0x9b, 0xbc, 0x29, 0xb6, 0x18, 0x38, 0xac, 0xd9, 0xd8, + 0x02, 0x73, 0xaa, 0x3e, 0x71, 0x97, 0xb5, 0x37, 0xe0, 0x78, 0x4b, 0xf9, 0xdf, 0xe4, 0xb1, 0x00, + 0xd3, 0x75, 0x88, 0x7f, 0xd0, 0xd4, 0xdc, 0x37, 0x59, 0x0f, 0x47, 0x66, 0x47, 0xad, 0x3d, 0xe5, + 0x6c, 0x2a, 0x73, 0x7e, 0xad, 0xc4, 0x06, 0xc1, 0xd2, 0x1a, 0xad, 0x64, 0xcb, 0xa8, 0x06, 0xb3, + 0x55, 0x28, 0xe8, 0x4b, 0xec, 0xb1, 0x06, 0xca, 0x6b, 0x05, 0xd6, 0x8f, 0xd1, 0xda, 0x52, 0xb1, + 0x52, 0x45, 0x35, 0xc9, 0x06, 0xf0, 0x57, 0xa1, 0x58, 0xa5, 0x76, 0x6c, 0x08, 0x46, 0xd9, 0xc7, + 0x5b, 0x61, 0xfc, 0x7f, 0xa5, 0xc0, 0x86, 0x27, 0xbf, 0xd1, 0x67, 0xed, 0x55, 0x16, 0x18, 0x88, + 0x32, 0x69, 0x83, 0xb1, 0x9f, 0xca, 0xff, 0xfa, 0xb0, 0x15, 0x3f, 0x73, 0x10, 0x31, 0xe0, 0x6b, + 0x68, 0x8c, 0x72, 0x2a, 0x5d, 0xcd, 0xa5, 0xb3, 0x30, 0xf4, 0x98, 0x65, 0x55, 0x8b, 0x6b, 0xe5, + 0x02, 0x8c, 0x58, 0xa8, 0x32, 0xf4, 0xb5, 0xc6, 0xd2, 0xc5, 0x62, 0xc9, 0x46, 0x35, 0xcf, 0x5b, + 0xa0, 0x6b, 0x73, 0x30, 0x9f, 0x5d, 0x49, 0xa5, 0xcf, 0x73, 0x8f, 0x94, 0x17, 0x0f, 0x81, 0xf6, + 0xba, 0x4e, 0x14, 0x57, 0x8a, 0xf9, 0xa2, 0xfd, 0xe0, 0x5a, 0x76, 0x2d, 0x2b, 0x2a, 0x87, 0xb1, + 0x4d, 0xba, 0xb8, 0x5a, 0xca, 0x56, 0x73, 0xd5, 0xdc, 0x59, 0x59, 0xbc, 0x07, 0x26, 0xc9, 0xc4, + 0x74, 0x4e, 0x9c, 0x3d, 0x21, 0x4a, 0x47, 0x40, 0x39, 0x1e, 0x38, 0x97, 0xcd, 0x9e, 0xc9, 0x16, + 0x32, 0x36, 0x4d, 0x26, 0x7b, 0x9e, 0xa1, 0xb9, 0x7e, 0x20, 0x5f, 0x4c, 0x03, 0x64, 0x30, 0x15, + 0x6b, 0xf2, 0xef, 0xfb, 0xad, 0x43, 0x14, 0xe3, 0xc1, 0x65, 0x93, 0x88, 0x2a, 0xd1, 0xd9, 0x20, + 0xee, 0x01, 0x4f, 0x3c, 0x50, 0xbb, 0x32, 0x6f, 0x8d, 0x49, 0xb2, 0x17, 0xe7, 0x87, 0xdc, 0x40, + 0xbf, 0x75, 0x3a, 0xae, 0x83, 0x69, 0x21, 0x92, 0xf8, 0xaf, 0x89, 0x2f, 0xf5, 0x59, 0xfb, 0x8d, + 0x92, 0x90, 0xa7, 0xd2, 0x27, 0x6d, 0xca, 0x96, 0xd7, 0xde, 0xc2, 0x68, 0xa5, 0x1c, 0x41, 0xb0, + 0x3e, 0xb0, 0xe8, 0x56, 0x03, 0x2c, 0x3c, 0x51, 0x3e, 0x20, 0x33, 0x38, 0x40, 0x56, 0xab, 0x78, + 0x10, 0xb4, 0x5e, 0x77, 0x2e, 0x21, 0x4d, 0x0b, 0xbf, 0x4b, 0x45, 0xc2, 0x8d, 0x62, 0x11, 0x5c, + 0x19, 0x96, 0x66, 0x04, 0xef, 0xd2, 0xde, 0x74, 0x9b, 0x75, 0x11, 0x97, 0x81, 0x16, 0xe6, 0x78, + 0xbc, 0x72, 0x44, 0x66, 0x5c, 0x98, 0xdd, 0xad, 0x7b, 0x8d, 0xa6, 0xe8, 0x73, 0xaf, 0x38, 0x46, + 0xb8, 0x11, 0x31, 0x42, 0xc6, 0x91, 0x54, 0xab, 0x05, 0xed, 0x0c, 0x9a, 0x47, 0x74, 0x48, 0x11, + 0x72, 0x9f, 0x7a, 0xf2, 0x41, 0xeb, 0xa8, 0x6c, 0x51, 0x4a, 0x2f, 0x81, 0xfb, 0xa4, 0x19, 0x67, + 0x08, 0xbd, 0x0d, 0x8a, 0xc0, 0x6b, 0x39, 0xc2, 0x03, 0x87, 0x02, 0xf4, 0x15, 0xc1, 0x55, 0x14, + 0xf8, 0x01, 0x54, 0x6e, 0xd7, 0x30, 0x4e, 0x11, 0x04, 0xc5, 0x27, 0xdf, 0xd1, 0x07, 0x1b, 0x5b, + 0xc2, 0x4c, 0x9a, 0x1c, 0xc0, 0x9e, 0x76, 0xdb, 0x1e, 0x85, 0x7e, 0x5c, 0x3d, 0xac, 0xd5, 0x27, + 0x57, 0xcb, 0xc3, 0x45, 0x36, 0x3f, 0x2e, 0x34, 0xfc, 0xcf, 0xc3, 0x68, 0xb2, 0x3f, 0xb9, 0x8b, + 0x07, 0x4f, 0x7a, 0xc8, 0x1d, 0x30, 0x4f, 0x01, 0x67, 0xc2, 0x7c, 0x3f, 0x12, 0xcb, 0x65, 0xd7, + 0x69, 0x63, 0x7c, 0x86, 0x1f, 0x98, 0x22, 0x5e, 0xc1, 0xbe, 0x52, 0xbe, 0xe1, 0xb0, 0x6c, 0xe5, + 0x77, 0x76, 0x9a, 0x2e, 0x39, 0x6c, 0xe4, 0x61, 0x69, 0xae, 0x02, 0x39, 0xb1, 0xe4, 0xe3, 0x4f, + 0xbe, 0xa2, 0xcf, 0x3a, 0x12, 0xcc, 0x1d, 0xbd, 0x91, 0x8a, 0x48, 0xe4, 0xf8, 0xdf, 0x67, 0xf6, + 0x93, 0xf3, 0xe0, 0x45, 0x93, 0xe9, 0xc0, 0x83, 0xa9, 0x29, 0xae, 0x08, 0xd7, 0xb6, 0x37, 0xc0, + 0x02, 0xa5, 0x79, 0x3a, 0x42, 0x97, 0xf2, 0x79, 0x62, 0x4c, 0x46, 0x05, 0x86, 0x27, 0x53, 0x48, + 0x22, 0xd8, 0x38, 0x55, 0xaf, 0x53, 0x0c, 0xd6, 0x69, 0xae, 0xb5, 0x1a, 0x9d, 0x5c, 0x0b, 0x19, + 0xc8, 0x6b, 0xef, 0xa0, 0x69, 0xd5, 0x85, 0x02, 0x3d, 0xf0, 0x02, 0xe3, 0xe3, 0xb6, 0x73, 0xb6, + 0xdb, 0x3f, 0xb9, 0x62, 0x1d, 0xe6, 0x5d, 0xd0, 0xde, 0x92, 0x50, 0xe7, 0x26, 0x06, 0x92, 0x87, + 0xcf, 0xfd, 0x9b, 0x3e, 0xe2, 0x8b, 0x7d, 0x22, 0x6e, 0xd9, 0x2f, 0xc3, 0x79, 0x12, 0x83, 0xc4, + 0x45, 0x93, 0xcf, 0xea, 0xb3, 0x6e, 0x53, 0xd4, 0xc7, 0x4f, 0x17, 0x96, 0xc1, 0x82, 0x76, 0xfc, + 0x9d, 0x0a, 0xa8, 0xc9, 0x7a, 0xb7, 0xe9, 0xd6, 0x79, 0xc7, 0x30, 0x01, 0x12, 0x09, 0x62, 0x45, + 0x18, 0xe5, 0x51, 0xca, 0xb6, 0x5f, 0xe6, 0x63, 0xac, 0xf3, 0xa6, 0x32, 0xb5, 0x42, 0x8e, 0x82, + 0x41, 0x08, 0xdf, 0x75, 0xd0, 0x7d, 0x1c, 0x94, 0x3c, 0xad, 0x8e, 0x34, 0xf1, 0x44, 0xd5, 0xe1, + 0xdc, 0x0a, 0x68, 0x3d, 0x24, 0x27, 0x73, 0xda, 0xf1, 0x71, 0xff, 0x1f, 0xec, 0xba, 0x80, 0x90, + 0x38, 0x71, 0x21, 0x18, 0x41, 0x46, 0x68, 0x07, 0x27, 0xef, 0xb6, 0xae, 0x0b, 0x35, 0x2e, 0xbb, + 0xfe, 0xb6, 0xd7, 0xf2, 0xe9, 0x2c, 0x02, 0xf3, 0x41, 0x10, 0x9e, 0xa3, 0x65, 0x32, 0x6d, 0x8d, + 0x87, 0x80, 0x33, 0xee, 0xba, 0xdf, 0x7b, 0x34, 0x24, 0x0a, 0xce, 0x76, 0x14, 0x85, 0xe3, 0xbb, + 0x70, 0xdc, 0xba, 0x3e, 0xa6, 0x13, 0x35, 0x2a, 0xe0, 0x48, 0x8e, 0xea, 0x8b, 0x61, 0xff, 0xab, + 0x75, 0x83, 0x6c, 0x91, 0x06, 0x98, 0xee, 0x96, 0x2b, 0xb0, 0x5d, 0x85, 0x1d, 0x73, 0x3b, 0x57, + 0xb5, 0xd0, 0x5d, 0x10, 0x3d, 0xe9, 0x5a, 0xb7, 0xee, 0xd6, 0xff, 0x32, 0x78, 0x7a, 0xdd, 0xb6, + 0xfb, 0xff, 0x7a, 0x98, 0x65, 0xeb, 0x26, 0x1c, 0x66, 0x25, 0x5d, 0xf5, 0x56, 0xd2, 0x92, 0x5e, + 0xdc, 0x0e, 0x51, 0x64, 0x9e, 0x60, 0x0d, 0xc7, 0xb9, 0x4f, 0x1e, 0xff, 0x04, 0xfd, 0x70, 0x4e, + 0x70, 0x60, 0xcb, 0xb8, 0x0f, 0xb0, 0xea, 0x6c, 0xe7, 0x3d, 0x2e, 0x21, 0xb9, 0xae, 0xef, 0x9d, + 0xe4, 0x77, 0x14, 0x4f, 0x21, 0x38, 0xa8, 0xec, 0x69, 0x28, 0x38, 0x34, 0x54, 0x49, 0x6a, 0x3c, + 0x54, 0x36, 0x79, 0x0e, 0xa4, 0x09, 0x4c, 0xb5, 0x80, 0x11, 0x5d, 0x61, 0x2f, 0xaf, 0x6d, 0xd7, + 0xc5, 0x69, 0x86, 0x10, 0xc4, 0x5a, 0xbc, 0x14, 0x03, 0x1b, 0x40, 0xd7, 0xc1, 0xb1, 0x77, 0x7f, + 0x10, 0xd4, 0x14, 0x89, 0x58, 0xa2, 0xe3, 0x5b, 0x41, 0xf9, 0x42, 0xc7, 0xab, 0xce, 0x45, 0xb7, + 0x08, 0xc2, 0xa7, 0x0d, 0xc0, 0x3a, 0x0e, 0x69, 0xcd, 0x93, 0x47, 0x38, 0x41, 0x97, 0xf9, 0xb9, + 0xb6, 0x84, 0xf3, 0x27, 0xdf, 0xd0, 0xc7, 0x09, 0x21, 0x5c, 0xa1, 0x68, 0x27, 0x65, 0xed, 0xf5, + 0x64, 0x21, 0xf4, 0x85, 0xaa, 0x76, 0x7a, 0x7a, 0xb7, 0x16, 0xd3, 0x05, 0xf7, 0xf2, 0x79, 0x10, + 0x64, 0xbe, 0x9a, 0x8c, 0x81, 0x0c, 0xca, 0x81, 0x99, 0x38, 0x65, 0xb1, 0x38, 0xb0, 0x20, 0xee, + 0xd8, 0x83, 0xb5, 0xa6, 0xac, 0x6b, 0xc5, 0x59, 0x10, 0x6c, 0x5f, 0x0a, 0x13, 0xa6, 0xf2, 0x0d, + 0xbf, 0x43, 0x69, 0x1f, 0x6a, 0x8f, 0xf8, 0x34, 0xf7, 0x4f, 0x9e, 0xb2, 0x6e, 0x41, 0xd8, 0x92, + 0xdb, 0x46, 0x89, 0x7c, 0xce, 0x6b, 0x37, 0xeb, 0x6b, 0x60, 0x7b, 0xe7, 0x3d, 0xef, 0x62, 0x77, + 0x5b, 0xcc, 0x9e, 0x24, 0x9c, 0x2f, 0x0f, 0x72, 0xb9, 0x1a, 0x7c, 0x4f, 0xbf, 0x35, 0xb9, 0x5b, + 0x43, 0x81, 0x98, 0x5f, 0xb0, 0x46, 0xf9, 0x49, 0x0f, 0x0f, 0x30, 0xf2, 0x13, 0xbd, 0xfb, 0xa6, + 0xaf, 0xdc, 0x72, 0x3a, 0x5b, 0xa6, 0x76, 0x69, 0x68, 0x96, 0x3c, 0x5c, 0x59, 0x4b, 0xa7, 0xb3, + 0x95, 0x8a, 0x9d, 0x4a, 0xa7, 0x8b, 0x6b, 0x85, 0xaa, 0xbd, 0x0c, 0xff, 0xcf, 0x84, 0xf8, 0x82, + 0xd3, 0xe8, 0x9b, 0xfa, 0xac, 0x51, 0xad, 0x29, 0x90, 0x5f, 0x7c, 0x63, 0x9e, 0x31, 0x90, 0x2d, + 0x97, 0x8b, 0x65, 0x7b, 0xad, 0x70, 0xa6, 0x50, 0x3c, 0x57, 0x00, 0x8b, 0xf0, 0x66, 0xeb, 0x06, + 0x51, 0x54, 0x41, 0xa7, 0x0c, 0x23, 0x36, 0xe7, 0xca, 0xc5, 0xc2, 0x0a, 0xb4, 0x29, 0x83, 0x19, + 0x06, 0x36, 0xe2, 0x9d, 0xd6, 0x6d, 0x1c, 0xa2, 0x50, 0xb4, 0x4b, 0xd9, 0xf2, 0x72, 0x36, 0x5d, + 0xb5, 0xcf, 0x15, 0xcb, 0xf9, 0x4c, 0xa8, 0xfb, 0x81, 0xc4, 0x1d, 0xd6, 0xad, 0x0a, 0x32, 0x9f, + 0x2b, 0x9c, 0xc9, 0x66, 0xec, 0x0a, 0xd9, 0x90, 0x26, 0xe0, 0xe0, 0xe4, 0x23, 0x7d, 0xa0, 0x9e, + 0xd2, 0x98, 0x3b, 0xd6, 0xaa, 0x83, 0x1d, 0x53, 0x95, 0x82, 0xda, 0xad, 0x67, 0x40, 0xd6, 0x9a, + 0x67, 0x95, 0x7d, 0x32, 0x6c, 0xb0, 0xb1, 0x2d, 0x95, 0x04, 0xfc, 0x78, 0x78, 0x7b, 0x2b, 0x30, + 0xb3, 0x30, 0x21, 0x56, 0xe6, 0x1f, 0x81, 0x24, 0xaf, 0x83, 0xe3, 0xb6, 0xe9, 0x0b, 0xfb, 0x4a, + 0x86, 0xae, 0xb7, 0xbb, 0xed, 0x1a, 0x08, 0x3b, 0x17, 0x93, 0x0c, 0x90, 0x0a, 0xca, 0xc0, 0xd9, + 0xc1, 0x0c, 0xd0, 0x67, 0xc7, 0x59, 0x34, 0x1b, 0x2d, 0x4c, 0xd5, 0x18, 0x24, 0x91, 0xdf, 0x27, + 0x63, 0x10, 0xbd, 0x67, 0x8a, 0xca, 0x0b, 0x33, 0x34, 0x50, 0xdc, 0xee, 0x9d, 0x5c, 0x00, 0x2a, + 0x34, 0xfb, 0x24, 0x2a, 0xbc, 0xc3, 0x1a, 0xa2, 0x5c, 0x15, 0xd1, 0xe1, 0xf8, 0x74, 0x8f, 0x81, + 0x27, 0xf3, 0xc0, 0x8c, 0x81, 0xca, 0xcd, 0x3e, 0xb9, 0xdb, 0xd8, 0xae, 0x34, 0xbd, 0x0e, 0x79, + 0x1c, 0x4d, 0xf4, 0xf7, 0x75, 0x59, 0x48, 0x51, 0x2f, 0x75, 0xfa, 0x67, 0x30, 0x09, 0x97, 0x81, + 0x8b, 0x56, 0x42, 0x8a, 0xda, 0xb2, 0x5b, 0x77, 0xdd, 0x2d, 0x94, 0xff, 0xc8, 0x12, 0x98, 0x8d, + 0x07, 0x8a, 0x2d, 0x08, 0x6e, 0x63, 0x5c, 0x44, 0xe2, 0xc7, 0x56, 0x86, 0xdb, 0xe4, 0xf3, 0x71, + 0x97, 0x22, 0x3d, 0x28, 0x42, 0x5f, 0xb6, 0x46, 0xda, 0xe2, 0x6f, 0x41, 0xe5, 0x77, 0x4c, 0xf7, + 0x06, 0x37, 0xa8, 0x7b, 0xf4, 0xa2, 0x5d, 0xe9, 0xd6, 0x6a, 0x2e, 0x40, 0xd5, 0x27, 0xef, 0x31, + 0xc9, 0x17, 0xdc, 0x25, 0xad, 0x96, 0x7b, 0x30, 0x17, 0xed, 0x65, 0xca, 0x67, 0x63, 0x7d, 0x93, + 0xaf, 0xda, 0xcb, 0xe5, 0x25, 0xd7, 0x20, 0x5b, 0x17, 0x9c, 0x4e, 0xde, 0xdb, 0xc8, 0x62, 0xf0, + 0x3f, 0x91, 0xd4, 0x0e, 0x96, 0xc6, 0x4e, 0x1e, 0x16, 0x71, 0xd3, 0xe2, 0xea, 0x52, 0xaa, 0x9a, + 0x2f, 0xae, 0x50, 0x46, 0x56, 0x25, 0x79, 0x38, 0x54, 0x9a, 0x49, 0xad, 0xa6, 0x56, 0xb2, 0x74, + 0xec, 0xed, 0xb4, 0x41, 0xd2, 0xda, 0xea, 0x48, 0x9d, 0x47, 0x8b, 0x79, 0xa1, 0x38, 0x90, 0x52, + 0x56, 0x1a, 0xcf, 0x4b, 0xec, 0x74, 0x1c, 0x50, 0x5a, 0x42, 0x48, 0x0c, 0xca, 0x26, 0x75, 0x67, + 0x0b, 0x8f, 0x17, 0xf4, 0x26, 0x01, 0x29, 0xb6, 0xd6, 0x9b, 0x8d, 0x1a, 0xd8, 0x50, 0xb6, 0x3a, + 0x76, 0xa5, 0xd4, 0x53, 0x30, 0x89, 0x54, 0x6f, 0x40, 0xcc, 0x5d, 0x8a, 0xab, 0xee, 0x91, 0x31, + 0x07, 0xbd, 0x96, 0xce, 0xf8, 0x47, 0x64, 0x1e, 0x04, 0x1e, 0xb2, 0xf0, 0x19, 0xaa, 0x56, 0x7b, + 0x65, 0x20, 0x28, 0xa8, 0xa3, 0x36, 0x96, 0xd6, 0x86, 0x62, 0x29, 0x4d, 0x57, 0x05, 0x3b, 0x47, + 0xb5, 0xac, 0x53, 0x59, 0x47, 0x61, 0xce, 0x7d, 0x54, 0x01, 0x2c, 0x76, 0xc9, 0x69, 0x76, 0x5d, + 0x71, 0xe4, 0x0b, 0x2c, 0xb6, 0xe9, 0x3a, 0xcd, 0xce, 0x26, 0x45, 0xf5, 0x87, 0x4c, 0x53, 0xeb, + 0x00, 0x19, 0xad, 0x68, 0xda, 0x76, 0xba, 0x2d, 0xbb, 0xde, 0xe5, 0x19, 0xb2, 0x14, 0xd8, 0xe7, + 0xc5, 0x18, 0x80, 0x53, 0xc5, 0x07, 0xa9, 0x58, 0x20, 0x40, 0x04, 0x6b, 0x3a, 0xde, 0xc6, 0x06, + 0x8c, 0x2f, 0x42, 0xf9, 0x74, 0x90, 0x1e, 0x53, 0xbb, 0xbe, 0x4e, 0x21, 0x7d, 0xf2, 0xab, 0x64, + 0x1d, 0x77, 0x73, 0x0e, 0xa9, 0xec, 0x6e, 0xa9, 0x84, 0x1f, 0xa6, 0x50, 0x7e, 0xbf, 0x51, 0xc6, + 0x73, 0xf0, 0xfa, 0x71, 0xe3, 0x37, 0xbc, 0x26, 0x46, 0xa3, 0xc9, 0xfc, 0xbb, 0x4e, 0x57, 0xb2, + 0xb4, 0x22, 0x40, 0xd2, 0x65, 0x3a, 0x78, 0xed, 0x47, 0x83, 0x63, 0xcb, 0xab, 0x83, 0xa7, 0x84, + 0xb9, 0x00, 0x72, 0x09, 0x47, 0xa9, 0x0a, 0x70, 0xf0, 0xf0, 0xb6, 0xec, 0x64, 0x42, 0xb2, 0x24, + 0xa5, 0x91, 0x6e, 0x36, 0x3a, 0x32, 0x5d, 0x4e, 0x27, 0x1a, 0x32, 0x7a, 0x6f, 0x50, 0x39, 0x17, + 0x7c, 0xa7, 0xa8, 0xf0, 0x46, 0x19, 0x10, 0xf6, 0x2e, 0xf8, 0x36, 0x3a, 0x59, 0x94, 0x50, 0x5b, + 0x73, 0x65, 0x7e, 0x1c, 0xec, 0x2d, 0x08, 0x83, 0x06, 0x86, 0xcc, 0xc8, 0xb8, 0x3f, 0x2e, 0xf2, + 0xd2, 0xc3, 0xe5, 0x27, 0x44, 0x62, 0x64, 0xb8, 0xfc, 0xa4, 0x48, 0x8a, 0x0c, 0x97, 0xdf, 0x1f, + 0xe4, 0x45, 0xfa, 0x38, 0x49, 0x91, 0x54, 0x7e, 0xab, 0x3c, 0x70, 0xda, 0x6c, 0xd4, 0xeb, 0x6e, + 0xcb, 0x96, 0x28, 0xa0, 0x63, 0x83, 0x10, 0x15, 0x5e, 0xc0, 0x63, 0x49, 0xb4, 0x4a, 0x9e, 0x40, + 0x75, 0x80, 0xb0, 0x96, 0xdb, 0xed, 0xb4, 0xc1, 0x65, 0xae, 0x21, 0x2a, 0x89, 0x3d, 0x6f, 0x97, + 0xd8, 0x69, 0x77, 0x5b, 0x2e, 0x2f, 0xba, 0x23, 0x76, 0x3e, 0x98, 0x65, 0x37, 0xc0, 0xa3, 0xb6, + 0x78, 0x60, 0xe9, 0xe2, 0xdd, 0x07, 0xe7, 0x12, 0xcf, 0x81, 0xa7, 0x54, 0x68, 0x28, 0x05, 0xa9, + 0xd1, 0x00, 0x33, 0xce, 0x95, 0xf4, 0x41, 0x61, 0x7d, 0xaa, 0x34, 0x38, 0x46, 0x90, 0xc6, 0xdd, + 0xd2, 0x0f, 0xd0, 0x18, 0x43, 0x54, 0xdd, 0xa3, 0x6b, 0x96, 0x7b, 0x75, 0x9d, 0x33, 0x2d, 0x27, + 0xc7, 0x23, 0x0e, 0x92, 0x82, 0x44, 0xdc, 0x1e, 0x8f, 0x8e, 0x05, 0x07, 0x62, 0x08, 0xaf, 0xb9, + 0x4e, 0x51, 0xfb, 0x91, 0xc9, 0xef, 0x0c, 0x73, 0x93, 0x44, 0xf8, 0x2d, 0xeb, 0x20, 0xbe, 0xd2, + 0xe8, 0x2f, 0xc7, 0x59, 0xb6, 0x40, 0xff, 0x17, 0x60, 0xae, 0x78, 0x0c, 0xd4, 0xaa, 0x47, 0x0e, + 0x59, 0xef, 0x04, 0xcf, 0xae, 0xe9, 0x75, 0x64, 0x02, 0xd2, 0xd1, 0xe9, 0x98, 0x6e, 0xa7, 0x49, + 0x4f, 0x00, 0xa2, 0x2e, 0x38, 0xf5, 0x0d, 0x95, 0x41, 0x3d, 0x28, 0x83, 0xde, 0x7c, 0xe6, 0xa2, + 0x74, 0x48, 0x46, 0xb1, 0x54, 0x04, 0x85, 0xc4, 0xd0, 0xc4, 0xef, 0x0f, 0x5a, 0x83, 0xd4, 0x8d, + 0xa6, 0x5c, 0xf8, 0xfc, 0x8e, 0x5b, 0xc3, 0x1d, 0xf0, 0x7f, 0x37, 0x79, 0xea, 0xcd, 0xe8, 0xc9, + 0x9b, 0x7b, 0x4e, 0x61, 0xba, 0x4a, 0x70, 0x89, 0x7b, 0xac, 0x41, 0xf4, 0x7b, 0x49, 0x56, 0x8e, + 0x9e, 0x3c, 0xd6, 0x1b, 0x1e, 0x6d, 0x69, 0x84, 0x26, 0xcf, 0x67, 0xf0, 0x4a, 0xd0, 0xa4, 0xc1, + 0xee, 0x11, 0x89, 0x4e, 0x43, 0x57, 0x82, 0x46, 0xd7, 0x33, 0xf1, 0x00, 0xac, 0x73, 0xcb, 0xeb, + 0x34, 0x6a, 0xc2, 0x53, 0x1e, 0x3d, 0x39, 0xd9, 0xbb, 0x45, 0x56, 0x40, 0x4e, 0x9c, 0xb0, 0x86, + 0xc5, 0x4a, 0x50, 0xb8, 0xd1, 0x5f, 0xc6, 0x79, 0xb3, 0x28, 0xe2, 0x39, 0x52, 0xb4, 0x4d, 0x13, + 0xbf, 0x00, 0xd8, 0xc3, 0xc5, 0x2c, 0x02, 0xf6, 0xe0, 0x5f, 0x09, 0x3e, 0x76, 0xf2, 0x86, 0xd8, + 0xf1, 0xb2, 0x08, 0x9c, 0xcb, 0x24, 0xd9, 0x45, 0x9b, 0x0e, 0x10, 0xed, 0x8a, 0xd7, 0xf4, 0xca, + 0x4e, 0xeb, 0x22, 0xe5, 0x3f, 0x60, 0x81, 0xde, 0xf9, 0x71, 0x6b, 0x90, 0xd6, 0x0e, 0x5c, 0x88, + 0x61, 0x62, 0xa7, 0xd9, 0xf8, 0x25, 0xb7, 0x1e, 0xb8, 0x8b, 0xfb, 0x22, 0x16, 0xf1, 0xc4, 0xa2, + 0x35, 0x48, 0xeb, 0x8f, 0x84, 0x24, 0xd0, 0xe9, 0xc3, 0x02, 0x3a, 0x61, 0x52, 0x89, 0x60, 0x9c, + 0x13, 0xf8, 0x65, 0x24, 0x52, 0x70, 0x13, 0x37, 0x59, 0x23, 0x12, 0x1d, 0x08, 0x20, 0x91, 0xa8, + 0x3a, 0x9a, 0xfc, 0xf5, 0x3e, 0x6b, 0x8f, 0x58, 0x05, 0x06, 0xfa, 0xc2, 0xeb, 0x00, 0xdb, 0xf2, + 0xb0, 0x75, 0x50, 0x96, 0x52, 0x6a, 0x26, 0x15, 0x63, 0x44, 0x63, 0x9f, 0x2c, 0x3e, 0x07, 0x93, + 0x00, 0xc3, 0x51, 0x6b, 0x0e, 0x3a, 0x7d, 0x0b, 0x4c, 0x23, 0x9f, 0x61, 0xfe, 0xc3, 0xb5, 0xb2, + 0x14, 0xcd, 0x24, 0x9f, 0x42, 0x19, 0x75, 0x36, 0x04, 0x22, 0xe7, 0x88, 0xac, 0x58, 0xc6, 0x43, + 0x16, 0x72, 0xeb, 0xc0, 0x1e, 0x73, 0xd9, 0xf0, 0xe4, 0xe3, 0x7d, 0xdc, 0xc3, 0x44, 0xd7, 0x8f, + 0x27, 0x2b, 0x82, 0x43, 0xb1, 0xd4, 0xf4, 0x3c, 0xb4, 0xdd, 0x40, 0x32, 0x71, 0xdf, 0xaa, 0x8e, + 0x68, 0x40, 0xad, 0x42, 0x87, 0x22, 0x22, 0x12, 0x01, 0x6c, 0xd8, 0xc2, 0xdb, 0x4e, 0x20, 0xaf, + 0x5a, 0x3c, 0xf7, 0x4c, 0xcf, 0x96, 0x43, 0xe6, 0xc2, 0x2c, 0x15, 0xdb, 0xd9, 0x22, 0xb1, 0x38, + 0xa0, 0xae, 0xf1, 0x74, 0x9c, 0x56, 0xfd, 0xc2, 0x4e, 0xa0, 0x11, 0x06, 0xa5, 0xc0, 0x0c, 0x77, + 0xc4, 0x63, 0x08, 0x3f, 0xec, 0x07, 0x0b, 0x46, 0xe4, 0xcb, 0x92, 0x9c, 0x4b, 0xcb, 0xfb, 0x10, + 0xbb, 0xf8, 0x94, 0x47, 0x34, 0x76, 0xed, 0xd7, 0xca, 0x0f, 0x07, 0xbc, 0x3a, 0x60, 0x80, 0x8f, + 0x05, 0xb7, 0x2c, 0x48, 0xc4, 0x0e, 0xaa, 0x28, 0x01, 0x4a, 0x02, 0xa7, 0xed, 0x6c, 0xd9, 0xc7, + 0x85, 0x28, 0x30, 0x0a, 0x4f, 0x08, 0xa3, 0x04, 0x93, 0x2a, 0xc4, 0x09, 0x88, 0x96, 0x89, 0x6f, + 0xb8, 0x6c, 0x23, 0xc1, 0x51, 0xa7, 0x88, 0x62, 0xc1, 0x2c, 0xf6, 0x4a, 0xa9, 0xa8, 0x8d, 0x8f, + 0xca, 0xc2, 0x92, 0xc6, 0x3a, 0x4f, 0x69, 0x1e, 0x95, 0x42, 0x48, 0xa4, 0xe5, 0xfb, 0xe2, 0xda, + 0x1b, 0x36, 0x14, 0x03, 0xd8, 0x14, 0x89, 0xe7, 0x36, 0x07, 0x38, 0xf4, 0xc3, 0xd9, 0x65, 0x6c, + 0x99, 0x98, 0xb4, 0x8e, 0xb9, 0xf8, 0x97, 0xcd, 0xd3, 0x0c, 0x3b, 0x65, 0xa0, 0xdc, 0x66, 0x73, + 0xad, 0xa5, 0xe6, 0x05, 0x84, 0x37, 0x6e, 0x1d, 0xe2, 0x30, 0x0f, 0xa2, 0x33, 0xa7, 0xf0, 0xcb, + 0xfa, 0xc1, 0xc4, 0x26, 0xea, 0xe0, 0x94, 0x81, 0xc1, 0x01, 0xde, 0x3c, 0xbc, 0x11, 0xd1, 0xf8, + 0x72, 0x68, 0x99, 0xdc, 0xc4, 0xfe, 0x86, 0x22, 0xb6, 0xd8, 0x6e, 0x94, 0xa9, 0xbc, 0x6a, 0x0d, + 0x73, 0x9f, 0x50, 0x88, 0x84, 0x7b, 0xa6, 0xaf, 0xa2, 0x95, 0xb4, 0x98, 0x93, 0x07, 0x5c, 0xfe, + 0x07, 0xb7, 0x8a, 0x7d, 0x7f, 0xf2, 0x97, 0x80, 0xf1, 0x78, 0x11, 0x86, 0xcd, 0x43, 0xb5, 0x60, + 0x31, 0x6b, 0x85, 0x19, 0x10, 0x54, 0xdb, 0x84, 0x13, 0xe0, 0x31, 0x59, 0x58, 0xf0, 0x3a, 0xcb, + 0xa8, 0x6a, 0x80, 0x17, 0x8f, 0x58, 0x09, 0x59, 0x9a, 0x56, 0xc8, 0x04, 0x8e, 0x04, 0xde, 0x53, + 0xfd, 0xd2, 0x79, 0x5c, 0xb6, 0xdd, 0xf6, 0xda, 0xe0, 0xba, 0xad, 0xf2, 0xb8, 0x14, 0xb2, 0xd7, + 0x76, 0x9a, 0x0e, 0x9e, 0x88, 0x37, 0xc9, 0xd1, 0xc1, 0x74, 0x29, 0x6f, 0xdb, 0xd6, 0xce, 0xa3, + 0xb8, 0xcf, 0x33, 0xa8, 0x4e, 0x6d, 0xbc, 0x75, 0xbb, 0xb3, 0x89, 0x11, 0xb5, 0x1d, 0xe1, 0xb8, + 0xbf, 0x6d, 0x22, 0x08, 0x2e, 0x97, 0xd1, 0xa8, 0x04, 0x5a, 0x93, 0x39, 0x15, 0x7e, 0xe2, 0x94, + 0x35, 0x44, 0x31, 0x1a, 0x42, 0xdb, 0xa8, 0xe1, 0x5f, 0x84, 0x40, 0xf9, 0x05, 0x0c, 0x99, 0x2a, + 0xf0, 0x44, 0x6b, 0x08, 0x2d, 0x29, 0x79, 0x06, 0x70, 0xfb, 0x2e, 0xed, 0xf4, 0x6c, 0x92, 0x9f, + 0xb3, 0xf6, 0x4a, 0x03, 0x46, 0x6a, 0xdb, 0xa9, 0x5d, 0x9a, 0x2e, 0x09, 0x58, 0xd9, 0x7c, 0xd6, + 0xb2, 0x36, 0xda, 0xce, 0xf6, 0x26, 0x0f, 0x18, 0x72, 0x65, 0x76, 0xdb, 0x2e, 0xed, 0x57, 0x10, + 0x98, 0xdc, 0x48, 0xca, 0x55, 0x6a, 0x76, 0x1c, 0x7b, 0xbd, 0x2d, 0xdd, 0x85, 0x91, 0x89, 0xbf, + 0x06, 0xbf, 0x5e, 0x9f, 0x9d, 0xc8, 0xcc, 0xc5, 0x0b, 0x2c, 0x17, 0x80, 0xa1, 0x94, 0x23, 0xa8, + 0x67, 0x6a, 0xef, 0x37, 0x73, 0xe2, 0x06, 0x64, 0x02, 0x5a, 0x90, 0xf0, 0x36, 0x48, 0x07, 0x9e, + 0x18, 0x2d, 0x26, 0xf5, 0xc2, 0x25, 0xc0, 0x5c, 0x90, 0xe5, 0x3c, 0x4c, 0xcb, 0xbe, 0x73, 0x97, + 0x69, 0x73, 0x72, 0xd5, 0x72, 0xf0, 0xbc, 0x56, 0x53, 0x1c, 0x20, 0x72, 0x8f, 0x05, 0xfc, 0x83, + 0xda, 0xa6, 0x8b, 0x9d, 0x91, 0x84, 0x98, 0x38, 0x67, 0x8d, 0xf2, 0xd0, 0x23, 0x6f, 0xa1, 0x9f, + 0xa5, 0x45, 0x52, 0x98, 0x49, 0xd6, 0x0c, 0x90, 0x5b, 0x81, 0xd9, 0xa8, 0x60, 0x99, 0x07, 0xa9, + 0x63, 0x64, 0x94, 0x72, 0x9b, 0x94, 0xa6, 0x3d, 0xe1, 0x58, 0x63, 0x22, 0xb0, 0x7d, 0xe5, 0xbe, + 0xd5, 0x7d, 0xda, 0x81, 0xe0, 0x10, 0x0f, 0x7a, 0xf7, 0x2e, 0xb7, 0x44, 0x9c, 0x9d, 0xb2, 0xc8, + 0x78, 0x09, 0x9e, 0x70, 0xd3, 0x10, 0xfd, 0x13, 0x69, 0xeb, 0x00, 0xaa, 0xd1, 0xaa, 0x27, 0xcf, + 0x28, 0xe8, 0xec, 0xe9, 0x12, 0xf8, 0x70, 0x20, 0x9c, 0xe4, 0x48, 0x2a, 0x04, 0xa1, 0x62, 0xd8, + 0xdc, 0x8e, 0x95, 0xaa, 0xf4, 0xa8, 0x35, 0x2a, 0xe6, 0x49, 0x6c, 0x22, 0x27, 0x89, 0x79, 0x92, + 0x9f, 0xdb, 0x6b, 0xed, 0x8f, 0x20, 0x34, 0xc8, 0x64, 0x50, 0x27, 0x8e, 0x7c, 0x7b, 0xd4, 0x2e, + 0xcb, 0xb5, 0x0d, 0x28, 0xbc, 0x21, 0xfa, 0x07, 0x03, 0xf7, 0xac, 0xed, 0xa9, 0x04, 0x3b, 0x58, + 0x18, 0x77, 0xd7, 0x84, 0xfd, 0x37, 0xac, 0xd2, 0x74, 0x9d, 0x87, 0x8d, 0x8a, 0x3d, 0xca, 0xd0, + 0xa7, 0xd2, 0xb6, 0xbb, 0xe1, 0xb6, 0x28, 0xa7, 0x6f, 0x44, 0x7a, 0x4f, 0x5b, 0x4e, 0xcb, 0x11, + 0xc0, 0x7b, 0xa5, 0x43, 0x03, 0xbd, 0x68, 0xc5, 0x56, 0x50, 0xdc, 0x72, 0x82, 0x1e, 0x46, 0xa5, + 0xfb, 0x47, 0xa9, 0x8c, 0x78, 0x31, 0xb7, 0xb5, 0x01, 0xfe, 0xe3, 0x3e, 0xa5, 0x59, 0xb1, 0xd8, + 0xd9, 0xe0, 0x26, 0xfc, 0x7e, 0x69, 0xa5, 0x53, 0x29, 0x74, 0xeb, 0x36, 0x9b, 0x8d, 0x0d, 0xba, + 0x5d, 0x34, 0x26, 0x7d, 0x3b, 0xde, 0xa0, 0xbd, 0xe5, 0xb5, 0xc9, 0xe3, 0x1c, 0x42, 0xc5, 0x41, + 0x65, 0x5b, 0xde, 0x25, 0x90, 0x9f, 0x2e, 0xa8, 0x27, 0x26, 0xe5, 0x36, 0x95, 0x73, 0xaf, 0x5c, + 0xe4, 0x08, 0xd3, 0x05, 0x07, 0x31, 0x87, 0x84, 0xda, 0x33, 0x31, 0xfc, 0xb5, 0x72, 0x52, 0xc6, + 0xc8, 0x87, 0xe4, 0x4e, 0xf3, 0x41, 0x0f, 0x4b, 0xcf, 0x37, 0x18, 0xef, 0x88, 0x8a, 0x3f, 0xf1, + 0xa1, 0xae, 0x33, 0x6c, 0x2b, 0x51, 0x38, 0xae, 0x2c, 0x48, 0xef, 0x32, 0x7a, 0x91, 0xbc, 0xf4, + 0xa8, 0x48, 0x90, 0xde, 0xcb, 0xbd, 0x98, 0x06, 0xdd, 0xbb, 0x12, 0xa9, 0xbb, 0x3d, 0xf9, 0x30, + 0x44, 0xfa, 0x8a, 0xc0, 0xaf, 0x97, 0x38, 0x42, 0x9a, 0x14, 0x3e, 0x9c, 0xf2, 0x33, 0x29, 0x36, + 0x26, 0x0a, 0x6f, 0x54, 0x3e, 0x29, 0xa7, 0x56, 0x51, 0x7c, 0x4c, 0x4e, 0x11, 0x9c, 0xbd, 0x86, + 0x2b, 0x4b, 0x6f, 0x92, 0x88, 0x6b, 0xca, 0xe6, 0x37, 0x07, 0xd4, 0x05, 0xeb, 0x43, 0x9a, 0x41, + 0xc7, 0xef, 0x16, 0x59, 0x4a, 0x5e, 0x35, 0x5e, 0xf8, 0xc0, 0xdb, 0xab, 0x93, 0x72, 0x4e, 0xe0, + 0x24, 0xcb, 0xb2, 0x5b, 0x65, 0x8f, 0x2d, 0x70, 0x9e, 0x10, 0x5a, 0x5c, 0xd7, 0x02, 0x6a, 0xa6, + 0x5f, 0xfc, 0xa6, 0x16, 0x25, 0xff, 0xdf, 0x1e, 0x24, 0xff, 0xdf, 0x21, 0x99, 0x15, 0x63, 0x4f, + 0xce, 0x65, 0x61, 0x59, 0xdd, 0x49, 0xdb, 0x01, 0x24, 0xa3, 0xfc, 0x41, 0xc5, 0xdd, 0x77, 0xa9, + 0x6d, 0x70, 0x7c, 0xf0, 0x4f, 0x77, 0xd0, 0xd3, 0x12, 0x5e, 0xe2, 0x13, 0xe5, 0x99, 0xd5, 0xdd, + 0x57, 0x54, 0x13, 0xba, 0x00, 0x4b, 0x92, 0x28, 0xf2, 0x37, 0x79, 0xdb, 0x7b, 0x7e, 0xa6, 0xb6, + 0x3f, 0x6f, 0x31, 0x6a, 0xb6, 0x09, 0x6a, 0x19, 0xd0, 0xd5, 0x04, 0xbc, 0x83, 0xb7, 0xf9, 0xb3, + 0xf4, 0x30, 0x6f, 0x8d, 0xd2, 0x3e, 0x0b, 0x86, 0x9b, 0xbe, 0x62, 0x63, 0x5d, 0xf4, 0x2c, 0x5b, + 0x09, 0xda, 0xad, 0x8e, 0xc7, 0x7d, 0x5f, 0x74, 0x34, 0x30, 0x03, 0xed, 0x4a, 0xaa, 0x2e, 0x2c, + 0x03, 0x71, 0xd7, 0x9d, 0xc0, 0xfb, 0xe6, 0x3e, 0x2f, 0xe2, 0x5f, 0x2f, 0xb5, 0x51, 0x06, 0x50, + 0xb2, 0xda, 0xc8, 0xc4, 0xa3, 0x7d, 0xd6, 0x81, 0xb0, 0xbe, 0x8c, 0x39, 0xf9, 0x73, 0x28, 0x78, + 0x30, 0x40, 0x7b, 0x0c, 0xd5, 0x4d, 0xa7, 0x25, 0x2d, 0x57, 0xd2, 0x0d, 0xa0, 0xf6, 0x86, 0xd4, + 0x2f, 0xb4, 0x6a, 0x87, 0x03, 0x1a, 0xd9, 0x13, 0xd0, 0xc8, 0x88, 0x0c, 0xc9, 0xd4, 0xc1, 0xfa, + 0x6b, 0x7b, 0x78, 0x15, 0x99, 0xa2, 0x62, 0x13, 0x05, 0x6b, 0xf4, 0x0c, 0x30, 0x85, 0x26, 0x6a, + 0xc5, 0xb5, 0x16, 0x25, 0x6a, 0x81, 0x44, 0x39, 0x8b, 0x28, 0xcb, 0x7f, 0x08, 0xcd, 0x1a, 0x64, + 0x25, 0xbc, 0xfd, 0xa2, 0xa0, 0xb9, 0x60, 0x3f, 0x6b, 0x25, 0xd4, 0x19, 0xba, 0x21, 0xc1, 0xc3, + 0xdd, 0xd2, 0x51, 0x6f, 0x93, 0x2e, 0x8f, 0xf0, 0x68, 0x9c, 0x4a, 0x1d, 0x50, 0xc5, 0x64, 0x3a, + 0x88, 0x7e, 0xef, 0xb1, 0xc6, 0x4a, 0x8d, 0xda, 0xc5, 0x25, 0xa7, 0xa5, 0xe1, 0x8a, 0xda, 0x05, + 0xc7, 0xb5, 0x0a, 0x73, 0x13, 0x3f, 0x19, 0xb0, 0xf6, 0x19, 0xe6, 0x0f, 0xf7, 0x12, 0xf9, 0x4d, + 0x0b, 0x61, 0x1c, 0xd0, 0xd5, 0x11, 0x3a, 0xda, 0x47, 0x40, 0x75, 0x84, 0x66, 0x84, 0xee, 0x82, + 0x0b, 0x40, 0x0d, 0x6e, 0xaa, 0xa1, 0x99, 0xc6, 0x95, 0x23, 0x8f, 0xc1, 0xb5, 0x1a, 0x1b, 0x9b, + 0x1d, 0x80, 0x6d, 0x52, 0xd0, 0x13, 0x7f, 0x88, 0xcb, 0x2c, 0x46, 0xc0, 0x7e, 0x58, 0xca, 0x63, + 0x1c, 0xbb, 0x51, 0x57, 0x41, 0xc6, 0x11, 0xfd, 0x7e, 0x11, 0x94, 0x53, 0x80, 0x91, 0xab, 0x91, + 0x59, 0x6b, 0x08, 0x4f, 0x84, 0x79, 0x0e, 0xf3, 0xee, 0x52, 0x2f, 0x84, 0x97, 0x19, 0x6b, 0xf0, + 0x02, 0x38, 0x59, 0xa0, 0x60, 0x7e, 0xc6, 0x86, 0x4f, 0x94, 0x3a, 0x7b, 0xdf, 0x15, 0x19, 0x48, + 0x27, 0x99, 0x34, 0xe8, 0xaa, 0x60, 0xc7, 0x31, 0xdf, 0x19, 0x5b, 0xdf, 0xbb, 0x9b, 0x95, 0x18, + 0x4b, 0x20, 0x41, 0x2a, 0xe5, 0x98, 0x0a, 0x16, 0xaa, 0xb3, 0x47, 0x95, 0xbc, 0xef, 0xa3, 0x88, + 0x10, 0xe9, 0x22, 0x8c, 0x30, 0x8d, 0xe1, 0x7b, 0xb2, 0xad, 0x40, 0x8c, 0x3a, 0x17, 0xb9, 0x3a, + 0x9b, 0xf8, 0xfa, 0x80, 0xb5, 0x37, 0x30, 0x26, 0x13, 0xd2, 0x0c, 0x25, 0x29, 0x8a, 0x66, 0xc6, + 0x10, 0x5d, 0x38, 0xa0, 0xb2, 0x87, 0xb7, 0xc9, 0x26, 0x1e, 0x0a, 0xa0, 0xe8, 0x35, 0x91, 0x01, + 0x2a, 0xc3, 0x58, 0x28, 0x95, 0x91, 0x72, 0xa2, 0x1b, 0x6c, 0xa4, 0xe3, 0x78, 0x61, 0x9b, 0x8c, + 0x22, 0x2c, 0x2a, 0x88, 0xeb, 0x12, 0x4d, 0xaf, 0x26, 0x24, 0x08, 0xb7, 0x1a, 0x4f, 0x5d, 0x8d, + 0xb1, 0x4b, 0x16, 0xb7, 0x7e, 0x94, 0xea, 0x4f, 0x1c, 0xb3, 0xf6, 0x1b, 0x05, 0x3c, 0x99, 0x01, + 0xfb, 0xa5, 0xd9, 0x4f, 0xfc, 0x1f, 0xd6, 0xc1, 0x48, 0xa3, 0x44, 0x16, 0x30, 0xa6, 0xc6, 0xe7, + 0x27, 0x2b, 0x27, 0xaf, 0x6a, 0x7c, 0xa3, 0x9b, 0xc9, 0x5f, 0xb0, 0x86, 0x08, 0x02, 0x9d, 0xa6, + 0x74, 0xdb, 0x75, 0xb7, 0x57, 0x00, 0x6b, 0x59, 0xa7, 0xdd, 0xa2, 0xb3, 0x87, 0x84, 0x35, 0x86, + 0xbb, 0xaf, 0x95, 0xf5, 0x61, 0x22, 0x54, 0x06, 0x45, 0x44, 0xaa, 0x55, 0x5f, 0xe2, 0xea, 0x04, + 0xab, 0xf3, 0x9e, 0xdf, 0xe1, 0x29, 0x5d, 0x0f, 0x95, 0x04, 0xe8, 0xc0, 0xe4, 0x39, 0x6b, 0xaf, + 0x2b, 0x87, 0xc3, 0xa4, 0xb0, 0x25, 0xaf, 0x93, 0x07, 0x91, 0xc6, 0x33, 0xc4, 0x56, 0x1b, 0x75, + 0xfa, 0xd1, 0x87, 0x3f, 0xc0, 0x9b, 0xa2, 0x1f, 0xfd, 0xb0, 0x2f, 0xc3, 0x4f, 0xea, 0xe2, 0xb6, + 0xf3, 0x94, 0xb0, 0x54, 0xab, 0x86, 0xae, 0x2a, 0xc6, 0x43, 0xf6, 0x5a, 0x43, 0x45, 0xf0, 0x9e, + 0xda, 0x6c, 0x68, 0xf2, 0x8d, 0x23, 0xd6, 0xb1, 0x9e, 0x6b, 0xad, 0x02, 0x79, 0xb8, 0xa0, 0x27, + 0x0c, 0xdf, 0xe9, 0x9e, 0xe9, 0xdd, 0xe1, 0x4d, 0x07, 0x2a, 0x69, 0x3a, 0x50, 0x77, 0x5f, 0xa9, + 0xb1, 0xee, 0xa7, 0x2c, 0x45, 0xbd, 0xa8, 0xfb, 0xae, 0xd4, 0x3e, 0xac, 0x1a, 0x7e, 0x2e, 0xc6, + 0x95, 0xba, 0xeb, 0x4a, 0x9d, 0x5c, 0xc1, 0x9f, 0x7a, 0xcd, 0xff, 0x7f, 0xfe, 0xd4, 0x42, 0xd8, + 0x9f, 0xba, 0xf7, 0x4a, 0x73, 0x37, 0x7c, 0x80, 0x89, 0x1f, 0xf5, 0xfd, 0xa7, 0x7b, 0x05, 0xca, + 0x5c, 0x1c, 0x8e, 0x31, 0x17, 0xf7, 0xc4, 0x99, 0x8b, 0x23, 0xf1, 0xe6, 0xe2, 0xde, 0x58, 0x73, + 0xd1, 0x8a, 0x98, 0x8b, 0xa3, 0x86, 0x71, 0xb7, 0x2f, 0x50, 0xdc, 0xfb, 0x03, 0xc5, 0x3d, 0x46, + 0x3e, 0xd7, 0x6e, 0xb6, 0x42, 0x5f, 0xd8, 0x56, 0xe8, 0x97, 0xb6, 0x02, 0xd9, 0x03, 0x03, 0x72, + 0x90, 0x9e, 0x96, 0x03, 0x0d, 0x39, 0x1c, 0x0c, 0xb9, 0x27, 0x6a, 0x2b, 0xd0, 0xe9, 0xda, 0xc4, + 0xeb, 0xfb, 0xfe, 0xbf, 0xd4, 0xaa, 0x86, 0x86, 0x1c, 0x24, 0x0d, 0x89, 0xcf, 0xb5, 0xf0, 0xdb, + 0x65, 0x81, 0x86, 0xb0, 0xf5, 0x74, 0x05, 0x3a, 0xa8, 0x36, 0x95, 0xc5, 0x9e, 0xa8, 0xb2, 0x18, + 0x11, 0xd1, 0xda, 0xdd, 0x35, 0xc0, 0xe4, 0xa2, 0x75, 0xb3, 0x19, 0x16, 0xa5, 0xb5, 0xad, 0xd0, + 0xd3, 0x17, 0xe2, 0xc2, 0x06, 0x9e, 0x9a, 0x68, 0x0f, 0x62, 0xa8, 0xfb, 0x1d, 0x7d, 0xf2, 0x01, + 0x14, 0x95, 0x4c, 0x54, 0xc9, 0x14, 0x95, 0x2d, 0x78, 0x1a, 0x68, 0x01, 0x73, 0xc2, 0x62, 0xf3, + 0x69, 0x82, 0x99, 0xf7, 0x07, 0xa7, 0x72, 0xea, 0x92, 0xd1, 0x80, 0x2c, 0xd3, 0x92, 0x79, 0x07, + 0xe5, 0xd1, 0xcb, 0x65, 0x18, 0x99, 0x5b, 0x17, 0xe2, 0x1c, 0x66, 0x58, 0x3f, 0xa1, 0xd9, 0x63, + 0x3a, 0xde, 0x23, 0xa1, 0xb3, 0xff, 0xbd, 0x61, 0x47, 0x9c, 0xe8, 0x71, 0xea, 0xbd, 0xef, 0xec, + 0xb3, 0xac, 0x2c, 0xdd, 0x53, 0xc1, 0xa5, 0x00, 0x31, 0x33, 0x4c, 0xb1, 0x47, 0xb4, 0x50, 0x3e, + 0x24, 0x38, 0x8a, 0xec, 0xa3, 0xa7, 0x12, 0x37, 0x58, 0xd7, 0xc9, 0xe2, 0x15, 0xba, 0x74, 0xd1, + 0x94, 0x31, 0x39, 0xf6, 0xb1, 0x53, 0x60, 0x0b, 0x8d, 0xab, 0x5a, 0x58, 0x1e, 0xe1, 0xb1, 0xd2, + 0xd8, 0x68, 0x15, 0xbb, 0x1d, 0xf6, 0x89, 0x53, 0xb0, 0xad, 0x37, 0xf7, 0xaa, 0x56, 0xbd, 0x7c, + 0xd2, 0x18, 0xe3, 0x49, 0x60, 0xc9, 0xa7, 0x37, 0x1d, 0x79, 0xb9, 0x81, 0x7d, 0xe6, 0x54, 0xe2, + 0x36, 0xeb, 0xa6, 0x1e, 0xb5, 0xaa, 0x8f, 0x7f, 0x3d, 0x95, 0xb8, 0xc9, 0x9a, 0x90, 0x50, 0xa4, + 0x18, 0x10, 0xd4, 0xad, 0xcb, 0x6e, 0x3e, 0x67, 0x4c, 0x95, 0x00, 0xf2, 0xee, 0xba, 0x1a, 0xe5, + 0xf3, 0x46, 0x35, 0xcf, 0xd5, 0xe3, 0x5b, 0x89, 0x9e, 0x02, 0xfb, 0xd2, 0xa9, 0xc4, 0xa4, 0x75, + 0x23, 0xaf, 0xe6, 0x11, 0x40, 0x1e, 0x2d, 0xa5, 0xf4, 0x18, 0x7e, 0x4f, 0x97, 0x7d, 0xd3, 0x44, + 0x86, 0x0b, 0x0b, 0xac, 0x49, 0xca, 0x72, 0x7d, 0xf6, 0x2d, 0xad, 0x0b, 0x6c, 0xaa, 0xd5, 0xa9, + 0x55, 0x7c, 0xfb, 0x54, 0xe2, 0x98, 0x75, 0x54, 0xc2, 0x54, 0x90, 0x0e, 0x96, 0x1b, 0x74, 0xaf, + 0x8d, 0x20, 0xd9, 0x0f, 0x8c, 0x21, 0xd2, 0xfc, 0xb2, 0x83, 0x5b, 0xe7, 0xc2, 0xd1, 0x67, 0x3f, + 0x34, 0x90, 0x90, 0xe2, 0x4f, 0x87, 0xa5, 0x29, 0xbf, 0xa1, 0x83, 0xd8, 0x67, 0x3f, 0x32, 0xda, + 0x57, 0x3a, 0xde, 0xb6, 0xd1, 0xfd, 0x8f, 0x4f, 0x25, 0x6e, 0xb6, 0xae, 0x97, 0xd5, 0xa5, 0x36, + 0x9e, 0x07, 0xd4, 0x5c, 0xca, 0x16, 0x4e, 0x53, 0xf4, 0x9b, 0xfd, 0xc4, 0x18, 0xc1, 0x80, 0xa0, + 0x3b, 0xcb, 0xec, 0x91, 0x99, 0x9e, 0x5d, 0xe4, 0x9d, 0x6e, 0x0b, 0x06, 0x79, 0xca, 0x8c, 0xbe, + 0x46, 0x13, 0x02, 0x51, 0xfd, 0xd4, 0x99, 0xc4, 0xed, 0xd6, 0x2d, 0x3d, 0xeb, 0x15, 0xae, 0x1e, + 0xed, 0xdd, 0x0f, 0xee, 0x3c, 0x7b, 0xda, 0x8c, 0x4e, 0x37, 0x46, 0x7d, 0xc5, 0xed, 0x08, 0x31, + 0xc6, 0x1e, 0x9b, 0xd1, 0x49, 0x34, 0x0c, 0x45, 0xe9, 0xac, 0x4d, 0xaf, 0xc3, 0x9e, 0x3e, 0x93, + 0xb8, 0xcb, 0xba, 0x4d, 0x82, 0xe5, 0xf8, 0xdb, 0x73, 0x14, 0x4e, 0x07, 0x91, 0xd0, 0x72, 0xc0, + 0x76, 0x57, 0xf3, 0x7a, 0x86, 0x31, 0xaf, 0xaa, 0x4a, 0x9a, 0x15, 0xc4, 0xc2, 0x9e, 0x35, 0xa3, + 0xa3, 0x50, 0xaf, 0x17, 0x1d, 0x3c, 0x7b, 0x46, 0x27, 0x14, 0x63, 0x4a, 0x0a, 0xe6, 0xd7, 0x0c, + 0x98, 0xd8, 0xcc, 0x65, 0xf6, 0xdc, 0x99, 0xc4, 0x2d, 0xd6, 0x0d, 0x12, 0x26, 0xdf, 0xb8, 0xe4, + 0x56, 0x50, 0x29, 0x5f, 0xf0, 0x9c, 0x76, 0x9d, 0x9f, 0xfb, 0xb0, 0xe7, 0xcd, 0x24, 0x6e, 0xb5, + 0x8e, 0x05, 0x34, 0xf9, 0x64, 0x71, 0x40, 0x20, 0xd9, 0x82, 0x36, 0xe4, 0x05, 0x33, 0x89, 0xbb, + 0xad, 0xdb, 0x77, 0x07, 0x52, 0x13, 0x7b, 0xe1, 0x0c, 0xc8, 0xcd, 0x23, 0x21, 0x60, 0xc9, 0x02, + 0x2f, 0x8a, 0x1b, 0x2e, 0xcc, 0x03, 0x2f, 0x8e, 0x03, 0xe2, 0x14, 0x0e, 0x30, 0x94, 0x46, 0xe2, + 0xb3, 0x97, 0xc6, 0xcd, 0x29, 0x04, 0xa4, 0x7a, 0xfc, 0xed, 0x19, 0x50, 0xc8, 0x07, 0x02, 0x60, + 0xa7, 0xbe, 0xb3, 0xb6, 0xcd, 0x5e, 0x36, 0x93, 0xb8, 0xc3, 0x9a, 0x94, 0xa5, 0x67, 0x30, 0xe1, + 0xb2, 0xbe, 0xdc, 0xf6, 0xb6, 0x56, 0x83, 0x07, 0x80, 0x60, 0x83, 0xbb, 0x2e, 0x7b, 0xdc, 0x58, + 0x12, 0xbf, 0x9a, 0x9f, 0x11, 0x6f, 0x1f, 0xb0, 0x97, 0x1b, 0xbb, 0x59, 0xe1, 0x77, 0x0c, 0xdd, + 0x65, 0x7a, 0x35, 0x8f, 0x58, 0xee, 0x77, 0x8c, 0x61, 0xa2, 0x00, 0x6a, 0x96, 0xaf, 0x98, 0x49, + 0x4c, 0x58, 0x87, 0xd5, 0xb6, 0x8b, 0xb5, 0xe0, 0x9b, 0x5b, 0x3e, 0x7b, 0xa5, 0x41, 0xcb, 0xa2, + 0xb4, 0x2c, 0x93, 0x1e, 0x25, 0x65, 0xfd, 0xae, 0x41, 0xcb, 0x51, 0x28, 0x31, 0xd0, 0xab, 0xcc, + 0x29, 0x77, 0x2f, 0x6c, 0x35, 0x3a, 0xfa, 0x70, 0xec, 0xd5, 0xe6, 0x94, 0x23, 0x00, 0xaa, 0xa7, + 0xdf, 0x9b, 0x49, 0x8c, 0xe3, 0xa9, 0x64, 0x20, 0xdf, 0x91, 0x2c, 0xf2, 0xde, 0x06, 0x7b, 0x4d, + 0x6f, 0xe6, 0x44, 0x4c, 0xb3, 0xd7, 0x1a, 0x62, 0x82, 0x77, 0x9b, 0x46, 0x55, 0xef, 0xcb, 0xc5, + 0xbc, 0xce, 0xa0, 0x5e, 0x13, 0x42, 0x0c, 0xff, 0xfa, 0x19, 0x5d, 0x9a, 0x49, 0x61, 0x2c, 0xee, + 0x9c, 0xf9, 0xec, 0x0d, 0x71, 0x84, 0xa4, 0xaa, 0xb9, 0x14, 0x67, 0xbf, 0x1f, 0xc2, 0x99, 0x09, + 0xa4, 0x86, 0xfa, 0x03, 0xa3, 0x2f, 0x93, 0x06, 0x14, 0xd0, 0x1b, 0x4d, 0xc6, 0x25, 0x8c, 0xf1, + 0x4c, 0x2d, 0xb0, 0x32, 0xb8, 0xac, 0x66, 0x6f, 0x32, 0xe6, 0x8c, 0xfc, 0x5f, 0xc6, 0x6b, 0x86, + 0xb2, 0xfa, 0xcd, 0xc6, 0x74, 0xc2, 0xd5, 0x32, 0xc1, 0x8c, 0xbd, 0x65, 0x26, 0x71, 0x04, 0x4f, + 0x93, 0x39, 0xd8, 0x39, 0xb2, 0x5d, 0x90, 0xd8, 0xde, 0x6a, 0xa0, 0x5d, 0x95, 0xab, 0x19, 0xbe, + 0xcd, 0x18, 0x1d, 0xfc, 0x7f, 0xae, 0xba, 0x24, 0xce, 0xff, 0xd0, 0x68, 0xae, 0x55, 0x8b, 0xe6, + 0x6f, 0x37, 0x76, 0x4d, 0x37, 0x07, 0x65, 0x0f, 0xff, 0xdd, 0xd8, 0x35, 0x13, 0x42, 0x74, 0xf2, + 0x47, 0x33, 0xba, 0xb6, 0x4f, 0xe3, 0xd3, 0x28, 0xcd, 0x60, 0x05, 0xef, 0x30, 0x98, 0x4d, 0xa4, + 0x08, 0xc8, 0xde, 0xff, 0xd8, 0x68, 0xaa, 0x2a, 0x45, 0xc7, 0xef, 0x9c, 0x01, 0xe3, 0x69, 0xbf, + 0xaa, 0xf5, 0xb6, 0xbb, 0xdb, 0xec, 0xcf, 0x66, 0x12, 0xf7, 0x58, 0x77, 0xe8, 0x56, 0x4d, 0x1a, + 0x6c, 0xc5, 0x36, 0xc9, 0xc9, 0x1d, 0x71, 0x44, 0xb8, 0xde, 0x6d, 0x0a, 0xc2, 0x7f, 0x97, 0x21, + 0x55, 0x38, 0x8f, 0xc6, 0x28, 0x20, 0x3e, 0x99, 0xbf, 0x31, 0xba, 0xee, 0x09, 0x2c, 0x26, 0xf7, + 0x9e, 0xde, 0x5a, 0x0d, 0xb5, 0x95, 0x82, 0x7b, 0xaf, 0x46, 0x00, 0xdc, 0x32, 0xcd, 0xd6, 0xbc, + 0x96, 0x2e, 0xd7, 0xed, 0x27, 0x79, 0x17, 0xd8, 0xdf, 0xce, 0x80, 0x01, 0x9e, 0x50, 0x48, 0x24, + 0xe5, 0x8c, 0xca, 0x8a, 0xbd, 0xcf, 0x60, 0xee, 0xa0, 0x42, 0x0d, 0xf0, 0x77, 0x06, 0xcf, 0x66, + 0x1a, 0x3e, 0x5a, 0x09, 0xd4, 0xf4, 0xfd, 0xc6, 0xee, 0x6a, 0x35, 0xaa, 0xed, 0x07, 0x0c, 0xfc, + 0x0b, 0x44, 0x90, 0x13, 0x09, 0x76, 0x36, 0xfb, 0x60, 0x48, 0x48, 0x19, 0xb5, 0xaa, 0x8f, 0x0f, + 0xcd, 0xe8, 0x76, 0xa6, 0x6a, 0xfc, 0xf7, 0x06, 0x83, 0x61, 0x31, 0x7f, 0x0a, 0xca, 0xe6, 0xff, + 0x90, 0xb9, 0xc5, 0xfe, 0x61, 0x26, 0xf1, 0x80, 0x75, 0x5f, 0x0c, 0x10, 0xa8, 0xe4, 0xad, 0x2d, + 0xb7, 0xde, 0x80, 0xc5, 0xca, 0x81, 0xaa, 0x9e, 0x68, 0xc9, 0xfe, 0x71, 0x26, 0x31, 0x65, 0x3d, + 0x21, 0xb6, 0x95, 0x9c, 0xa4, 0x80, 0x75, 0xd9, 0x3f, 0x19, 0x14, 0x10, 0x99, 0x86, 0xd6, 0x3b, + 0x4c, 0xe7, 0x9f, 0x7b, 0x01, 0x63, 0xc7, 0xe1, 0x59, 0x7c, 0xf8, 0xea, 0x81, 0x5d, 0xf6, 0x11, + 0x83, 0x0b, 0x50, 0x62, 0x62, 0x03, 0xfe, 0x50, 0x02, 0xfb, 0xa8, 0x81, 0x2a, 0xb3, 0x32, 0xb0, + 0xcc, 0x0d, 0x09, 0x41, 0x02, 0x8b, 0x36, 0xf9, 0xe3, 0x06, 0x8b, 0xab, 0x72, 0xd5, 0xee, 0x5f, + 0x8c, 0xce, 0x2b, 0xdd, 0x8d, 0x0d, 0xb1, 0x89, 0x9a, 0x5a, 0x64, 0x9f, 0x30, 0x8d, 0x26, 0x12, + 0x74, 0xe8, 0x01, 0xb9, 0xfe, 0xb2, 0xb8, 0x6d, 0xe5, 0xa7, 0xea, 0x75, 0xf6, 0xc9, 0x99, 0xc4, + 0x9d, 0xd6, 0xad, 0xbb, 0x82, 0x81, 0x76, 0xf2, 0xc0, 0x6a, 0xfc, 0xd4, 0x4c, 0xe2, 0xa8, 0x75, + 0x48, 0x42, 0x66, 0xeb, 0x8d, 0x0e, 0x8f, 0x70, 0x6d, 0x78, 0xec, 0xdf, 0x0c, 0x89, 0xa2, 0x57, + 0xa9, 0x39, 0x7f, 0xd6, 0x20, 0x4b, 0x30, 0xdb, 0xe4, 0x0d, 0x24, 0x1c, 0x8c, 0x7d, 0xce, 0x98, + 0x6c, 0x0a, 0x1f, 0xe7, 0xc0, 0x1e, 0xaa, 0x9e, 0xc1, 0x84, 0xec, 0xf3, 0x71, 0x16, 0x45, 0xae, + 0x05, 0x5b, 0xd7, 0xc2, 0x47, 0x03, 0x9c, 0x26, 0xbf, 0x92, 0x91, 0x05, 0x6d, 0xda, 0x64, 0x5f, + 0x30, 0x6d, 0x3c, 0x4c, 0x6c, 0x59, 0x07, 0x1a, 0x85, 0x6e, 0x29, 0xdb, 0x9e, 0x7d, 0xd1, 0x60, + 0x25, 0x12, 0x39, 0x81, 0xa1, 0x47, 0x72, 0xee, 0x4b, 0xda, 0x9c, 0xc5, 0x60, 0x3c, 0x5d, 0x1f, + 0x2f, 0x73, 0xb3, 0xaf, 0x68, 0x72, 0x5a, 0x2e, 0x53, 0xab, 0xfe, 0xf7, 0x99, 0xc4, 0xb4, 0x75, + 0x57, 0x4f, 0x61, 0x12, 0xbe, 0x1f, 0xce, 0xbe, 0x6a, 0xe0, 0xd0, 0x0e, 0xa6, 0x82, 0x27, 0x29, + 0x74, 0x5f, 0x88, 0x7d, 0xcd, 0x30, 0x70, 0xe3, 0x40, 0x14, 0xba, 0xbf, 0xae, 0x49, 0x90, 0xb4, + 0x23, 0x0c, 0xb8, 0xb3, 0x1e, 0x98, 0x93, 0xdf, 0xd0, 0x96, 0x6d, 0xd4, 0xa8, 0xb6, 0xff, 0xcb, + 0x58, 0x76, 0x07, 0x84, 0xe6, 0x25, 0x37, 0x68, 0xff, 0x4d, 0x4d, 0x82, 0x44, 0x6a, 0x55, 0x1f, + 0xdf, 0xd2, 0x48, 0x1b, 0x51, 0xbe, 0xec, 0xb4, 0xd6, 0x9d, 0x36, 0x38, 0x4f, 0xda, 0xa6, 0x28, + 0x96, 0xd2, 0xea, 0xbf, 0x63, 0x88, 0x60, 0xfe, 0x56, 0x05, 0x19, 0x01, 0x6b, 0xf4, 0x7c, 0x9a, + 0x54, 0xfa, 0xec, 0xbb, 0xbd, 0xe0, 0x24, 0x04, 0xcf, 0x04, 0x61, 0xdf, 0x33, 0x58, 0x45, 0x83, + 0x03, 0xd7, 0x2f, 0x0f, 0x1d, 0x52, 0x67, 0xdf, 0x37, 0xf1, 0x1a, 0x0b, 0x24, 0xfa, 0xfb, 0x81, + 0xe9, 0x18, 0xc0, 0xcc, 0x43, 0xea, 0xef, 0xc7, 0x06, 0x55, 0x19, 0x00, 0x02, 0x35, 0xff, 0x61, + 0x70, 0x82, 0x64, 0x16, 0xe9, 0xeb, 0xfc, 0xc4, 0x10, 0xd0, 0xa1, 0x5a, 0xd5, 0xc7, 0x4f, 0x67, + 0x4c, 0x17, 0xcf, 0x23, 0x7e, 0xd3, 0x14, 0xdf, 0x23, 0xb3, 0xa6, 0x8b, 0xa7, 0x01, 0x88, 0x2e, + 0x9e, 0x32, 0xab, 0x9b, 0xb2, 0xc2, 0xe0, 0x16, 0x5e, 0xf2, 0x53, 0x67, 0x75, 0xcd, 0x75, 0xda, + 0x69, 0x36, 0x8b, 0xeb, 0xcb, 0x88, 0xa9, 0x47, 0x67, 0x75, 0x9e, 0x0a, 0x2a, 0xe4, 0xb0, 0x4f, + 0x9b, 0xd5, 0xe7, 0xa5, 0xd7, 0x8b, 0x51, 0x7f, 0x79, 0x56, 0xdf, 0xb7, 0x15, 0xf1, 0x3e, 0x44, + 0x06, 0x7c, 0xb3, 0x4e, 0xa3, 0xee, 0x96, 0xf0, 0x15, 0x2c, 0xf2, 0x67, 0x1e, 0x9b, 0x35, 0x2d, + 0x4b, 0x7a, 0x55, 0x43, 0x87, 0xf2, 0xd9, 0xaf, 0xcc, 0xea, 0xc2, 0xc0, 0xac, 0xe4, 0x0d, 0x34, + 0xb3, 0xef, 0x19, 0xc6, 0xb8, 0xa7, 0xe9, 0xb5, 0x11, 0xd7, 0x6d, 0x9d, 0x6e, 0x6c, 0x6c, 0x92, + 0xc3, 0x25, 0x17, 0xf0, 0xcc, 0x59, 0xdd, 0xac, 0x8e, 0x83, 0x13, 0x1d, 0x3e, 0x6b, 0x56, 0x67, + 0xef, 0x9e, 0x0b, 0x09, 0x1c, 0xc6, 0x59, 0x43, 0x66, 0x77, 0xa0, 0x2f, 0xd8, 0x95, 0x2d, 0xaf, + 0x84, 0xaf, 0x37, 0xc8, 0xd1, 0x9f, 0x33, 0xab, 0x6f, 0x7e, 0x04, 0x48, 0xfa, 0x95, 0xb3, 0x46, + 0x80, 0x00, 0x8f, 0x94, 0xf3, 0x9e, 0xd7, 0x59, 0x69, 0xbb, 0xee, 0x25, 0x90, 0x7b, 0xcf, 0x35, + 0xf6, 0x00, 0x4c, 0x84, 0xad, 0x86, 0xef, 0xeb, 0x00, 0xcf, 0x9b, 0x35, 0x9d, 0x5b, 0x61, 0x03, + 0xa6, 0x55, 0x36, 0xda, 0xf3, 0x0d, 0x24, 0x44, 0x7b, 0x50, 0x33, 0xf9, 0x75, 0x63, 0x97, 0x96, + 0x9c, 0x26, 0x1a, 0x8a, 0xf5, 0xca, 0x66, 0x77, 0x7d, 0xbd, 0x29, 0x44, 0xf6, 0x0b, 0x0c, 0xc4, + 0xe3, 0x60, 0xe9, 0x4d, 0xb7, 0x76, 0x91, 0x0b, 0xca, 0x12, 0xde, 0xff, 0xf2, 0x31, 0x62, 0xc7, + 0x5e, 0x68, 0xe0, 0xb3, 0x27, 0x9c, 0x1a, 0xfa, 0x37, 0x66, 0x75, 0x3b, 0x9e, 0x83, 0xc9, 0xeb, + 0x95, 0x12, 0x9d, 0xbf, 0x39, 0x1b, 0x72, 0x08, 0x0c, 0x18, 0xd1, 0xd1, 0x8b, 0x0c, 0x6c, 0x98, + 0x40, 0xc8, 0x7e, 0xec, 0xc5, 0x06, 0x36, 0xa2, 0x00, 0xaa, 0xa7, 0x97, 0xc4, 0x4c, 0xc9, 0xcf, + 0xb5, 0x56, 0xbd, 0x56, 0x67, 0x53, 0x4e, 0xe9, 0xb7, 0x62, 0xa6, 0x14, 0xc0, 0x88, 0x8e, 0x5e, + 0x6a, 0x90, 0x81, 0xa6, 0xd4, 0x29, 0x7a, 0x29, 0xbb, 0xfa, 0xed, 0x59, 0x5d, 0x67, 0x46, 0xa1, + 0x44, 0x67, 0x2f, 0x33, 0xf8, 0x7c, 0xc9, 0x23, 0xd5, 0x26, 0x22, 0x45, 0x8f, 0x1b, 0x33, 0x96, + 0xb7, 0x0d, 0x45, 0x4c, 0x2d, 0xc5, 0x73, 0xf3, 0x5e, 0x3e, 0xab, 0x5b, 0x66, 0xb1, 0x30, 0x6a, + 0xac, 0xdf, 0x99, 0x0d, 0x44, 0x9b, 0xb8, 0xb8, 0x2b, 0x34, 0x22, 0x28, 0x28, 0xf6, 0x4a, 0x6d, + 0x59, 0x91, 0x5a, 0xd5, 0xc7, 0xef, 0x1a, 0xcb, 0x0a, 0xac, 0xa6, 0x90, 0x9c, 0x7d, 0x95, 0x31, + 0x75, 0xf2, 0x4d, 0x32, 0xf8, 0xba, 0x3b, 0x88, 0x6b, 0x64, 0x7b, 0x3c, 0x66, 0x60, 0xaf, 0x36, + 0x84, 0x20, 0x4d, 0xdd, 0xbc, 0x11, 0xc9, 0x7e, 0x6f, 0x56, 0xb7, 0x7e, 0x62, 0x20, 0xd4, 0xb4, + 0x5e, 0x63, 0x48, 0x3e, 0x28, 0x36, 0x60, 0x7d, 0xf6, 0x5a, 0x83, 0xce, 0x23, 0xf5, 0xaa, 0x9f, + 0xd7, 0x19, 0xdb, 0x81, 0xcb, 0x2b, 0xb6, 0xc4, 0xd2, 0xd8, 0xeb, 0x4d, 0xc6, 0x76, 0x3b, 0xcb, + 0xb0, 0x4b, 0xdd, 0xb6, 0x5b, 0x47, 0x04, 0x81, 0xaf, 0x6c, 0x34, 0x35, 0xeb, 0xde, 0x38, 0xab, + 0x6b, 0xe5, 0x75, 0x70, 0x42, 0x37, 0xcd, 0x97, 0x4c, 0xf2, 0x8d, 0xd6, 0x45, 0xf6, 0x26, 0x0d, + 0x8a, 0x3b, 0x2e, 0x30, 0xb1, 0x5f, 0x34, 0xa3, 0xb5, 0x3e, 0x7b, 0xb3, 0x81, 0x36, 0x64, 0x45, + 0xd0, 0x83, 0x78, 0xf9, 0x0f, 0xa1, 0xc8, 0xb6, 0x79, 0x8b, 0x81, 0xb6, 0x18, 0x08, 0xb5, 0xdc, + 0xb7, 0x9a, 0xbb, 0xe9, 0x09, 0x73, 0x36, 0xd5, 0x6c, 0x1a, 0x43, 0xbe, 0x2d, 0x02, 0xc6, 0x83, + 0x5f, 0xf2, 0x23, 0x15, 0x00, 0x0b, 0x9e, 0x2e, 0xfb, 0x43, 0x83, 0x57, 0x57, 0xf0, 0xc0, 0x85, + 0x53, 0xb2, 0xa4, 0x8a, 0xb7, 0x1b, 0x53, 0x37, 0x00, 0xc4, 0x84, 0xfe, 0xbb, 0xc1, 0xcd, 0x04, + 0x01, 0x88, 0x16, 0xe3, 0x94, 0xbd, 0x80, 0xc0, 0xfe, 0xc8, 0x58, 0x63, 0x2c, 0xa0, 0xe8, 0xf2, + 0x1d, 0xb3, 0x31, 0x21, 0x0e, 0x6a, 0x40, 0x5e, 0xd3, 0x1f, 0xcf, 0xea, 0x56, 0x7e, 0x50, 0xfe, + 0x4e, 0x53, 0x15, 0x62, 0x39, 0x77, 0x2d, 0xe4, 0x18, 0x62, 0x22, 0x7f, 0x12, 0x9d, 0x71, 0x08, + 0x4e, 0xcc, 0xe3, 0x4f, 0x0d, 0x24, 0xf2, 0xc5, 0x93, 0xe7, 0xce, 0xc1, 0x65, 0x7f, 0x7f, 0x16, + 0x1d, 0xd7, 0x04, 0x13, 0xdd, 0xfd, 0x79, 0x14, 0x8e, 0x6f, 0x4a, 0x28, 0x9c, 0xf0, 0xae, 0xe8, + 0xfc, 0x42, 0x70, 0xa2, 0xc3, 0x77, 0xcf, 0x9a, 0x41, 0x57, 0x0a, 0x2c, 0xf0, 0x41, 0x91, 0x76, + 0xd8, 0x5f, 0x44, 0x55, 0x85, 0x5e, 0xaf, 0xfa, 0xf9, 0xcb, 0x59, 0xdd, 0x80, 0xd2, 0xa8, 0x8f, + 0x92, 0xf5, 0xff, 0xca, 0x10, 0x9e, 0xa1, 0x5a, 0xd5, 0xc7, 0xff, 0x88, 0xd0, 0x38, 0x9f, 0x33, + 0x05, 0x93, 0x51, 0x7e, 0xb2, 0xf7, 0xc4, 0x8d, 0x42, 0x6e, 0x18, 0x8e, 0xf2, 0xde, 0xb8, 0x51, + 0x64, 0xad, 0x1a, 0xe5, 0x6f, 0x67, 0xc3, 0xc6, 0x60, 0x2e, 0xb3, 0xb4, 0x53, 0xd0, 0x0c, 0xa6, + 0xf7, 0x1b, 0x1a, 0xd4, 0x84, 0x90, 0x0e, 0xfd, 0xac, 0xee, 0x8c, 0x4b, 0x8b, 0x90, 0x7d, 0xd0, + 0xb4, 0xf0, 0x1c, 0xdf, 0xc7, 0xf0, 0x08, 0x77, 0xe3, 0x79, 0xdf, 0x1f, 0x32, 0xfa, 0x36, 0x21, + 0x44, 0xdf, 0x7f, 0x3f, 0xab, 0xfb, 0xb0, 0x05, 0x0f, 0x98, 0x37, 0x20, 0xd0, 0x7f, 0x34, 0x30, + 0xa0, 0x11, 0x1e, 0xd5, 0x7e, 0x38, 0x62, 0x45, 0xa0, 0xb5, 0x1c, 0xdc, 0x66, 0x66, 0x1f, 0x31, + 0xe8, 0x22, 0x0a, 0xa0, 0x26, 0xf1, 0xd1, 0xd9, 0x98, 0x18, 0xa0, 0x50, 0xfc, 0x68, 0x47, 0x95, + 0x3c, 0xaf, 0xc9, 0x3e, 0x3e, 0x1b, 0xe3, 0xfa, 0x85, 0x80, 0x02, 0x07, 0x79, 0x56, 0x0f, 0xfb, + 0x04, 0xbb, 0x5b, 0xdc, 0x76, 0xf9, 0xfa, 0xf8, 0xdd, 0x0e, 0x81, 0xa7, 0x4f, 0xce, 0x26, 0xee, + 0xb5, 0xee, 0xbc, 0x32, 0xb4, 0xe8, 0xfc, 0x53, 0x11, 0xf0, 0x0c, 0x3f, 0x87, 0x8d, 0xef, 0xfd, + 0xd3, 0x11, 0xc3, 0xa6, 0x07, 0xb8, 0xe8, 0xfe, 0x7f, 0x46, 0x65, 0x1c, 0x9f, 0xce, 0x2a, 0xbf, + 0x58, 0xcf, 0x3e, 0x63, 0xb0, 0x39, 0x35, 0x06, 0xc1, 0xa4, 0x7a, 0x93, 0xe3, 0xfe, 0xab, 0xc1, + 0x4d, 0x31, 0x60, 0x62, 0xbc, 0x7f, 0x33, 0x14, 0x29, 0xd5, 0x21, 0x90, 0x98, 0x14, 0x69, 0x12, + 0xf6, 0x59, 0xa3, 0x2f, 0x74, 0x5f, 0xe3, 0xd7, 0xfa, 0x39, 0x63, 0xcb, 0xe3, 0xe0, 0xc4, 0xa0, + 0x9f, 0x37, 0x44, 0x26, 0xa9, 0x04, 0xfd, 0x38, 0xf1, 0x8b, 0xb3, 0x7a, 0xfc, 0x0b, 0x6b, 0xe4, + 0xe2, 0xbf, 0x34, 0x1b, 0x3a, 0xbf, 0x13, 0x87, 0xba, 0x74, 0x40, 0xe6, 0xb3, 0x2f, 0x9b, 0x22, + 0x30, 0x54, 0xad, 0x86, 0xff, 0x8a, 0xc1, 0x19, 0x34, 0x3f, 0xe4, 0x2b, 0x1e, 0xb0, 0xe0, 0x4b, + 0xf9, 0x7a, 0x14, 0x2d, 0x01, 0x88, 0xe8, 0xe6, 0x1b, 0xa6, 0x0f, 0x80, 0x30, 0x98, 0x44, 0xd8, + 0x33, 0x1a, 0xf9, 0xbf, 0x66, 0x13, 0xf7, 0x59, 0x53, 0x57, 0x03, 0x2f, 0x06, 0xf8, 0xa6, 0x61, + 0x7b, 0x91, 0x97, 0x0f, 0x73, 0xf0, 0x50, 0x14, 0x82, 0x7f, 0x2a, 0x2d, 0x0b, 0xde, 0xf9, 0xb7, + 0x0c, 0x06, 0xe9, 0x05, 0x2b, 0xcf, 0x30, 0x0d, 0x3c, 0x85, 0x81, 0x5d, 0xf1, 0xec, 0x06, 0xfb, + 0x8e, 0x41, 0xea, 0xbd, 0xc0, 0x54, 0xaf, 0xdf, 0x9d, 0x35, 0x0e, 0xe0, 0x34, 0xf0, 0xa6, 0xeb, + 0xf8, 0xae, 0x36, 0x13, 0xf6, 0xbd, 0xd9, 0xc4, 0x09, 0xeb, 0x9e, 0xab, 0x01, 0x55, 0xbd, 0x7f, + 0x3f, 0xc6, 0x25, 0xac, 0x8a, 0x97, 0x34, 0x85, 0x4b, 0xf8, 0x03, 0x03, 0x5f, 0x79, 0xc7, 0xef, + 0x9c, 0x6e, 0x04, 0x77, 0x69, 0x94, 0x13, 0x57, 0xc2, 0xc4, 0xa7, 0x1f, 0x1a, 0x6b, 0xeb, 0x09, + 0x2b, 0xd1, 0xfb, 0x23, 0x63, 0xaf, 0x77, 0x01, 0x17, 0xb3, 0xfd, 0xb1, 0xc1, 0x0a, 0xdc, 0x08, + 0x11, 0xaf, 0x7a, 0x70, 0xa9, 0x25, 0x3b, 0xfe, 0x0f, 0xc3, 0xce, 0x88, 0x05, 0x14, 0x5d, 0xfe, + 0xc4, 0xd8, 0x34, 0x03, 0x86, 0xdb, 0x5c, 0xbc, 0xc3, 0xa7, 0xcc, 0xe9, 0xcc, 0x1a, 0x03, 0x26, + 0xba, 0x7b, 0xea, 0x9c, 0xae, 0x8e, 0x23, 0x70, 0xec, 0xd1, 0x39, 0x7d, 0x38, 0x63, 0x62, 0x3c, + 0x1a, 0x29, 0x5c, 0x7e, 0x63, 0xb8, 0x18, 0x30, 0xe9, 0xf9, 0xcf, 0xe9, 0x52, 0x1e, 0x77, 0x3b, + 0xa6, 0xb3, 0xc7, 0xe6, 0xc2, 0xd1, 0x8f, 0xb8, 0xae, 0x9e, 0x3e, 0xa7, 0x87, 0x98, 0x35, 0x08, + 0x0d, 0x0d, 0x4b, 0x3b, 0xe6, 0x8a, 0x32, 0xec, 0x57, 0xe6, 0x12, 0xf7, 0x5b, 0xd3, 0x57, 0x6a, + 0x55, 0xbc, 0x1c, 0xd8, 0xcc, 0xd0, 0xe8, 0x19, 0xc6, 0x84, 0x22, 0x8d, 0xc4, 0x84, 0x9e, 0x39, + 0xa7, 0x6b, 0xca, 0x10, 0x14, 0x7b, 0x96, 0xb1, 0x72, 0x39, 0xad, 0xc6, 0x25, 0x97, 0x47, 0x5b, + 0xb9, 0xb9, 0xf1, 0xec, 0xb8, 0x81, 0x96, 0x31, 0xa6, 0xa9, 0x43, 0xfd, 0xea, 0x9c, 0x1e, 0x83, + 0x15, 0x50, 0x3c, 0x2f, 0xe0, 0x39, 0x73, 0x61, 0x7d, 0x0c, 0xbc, 0x04, 0xde, 0x90, 0xc8, 0x94, + 0xf1, 0xd9, 0xaf, 0xf5, 0x5a, 0x8a, 0x41, 0xe7, 0xcf, 0x9d, 0x8b, 0x21, 0x32, 0x0d, 0x4a, 0xac, + 0xf8, 0x79, 0x73, 0x3a, 0xd5, 0xea, 0x60, 0x81, 0xb0, 0xe5, 0x1d, 0x3e, 0x7f, 0x4e, 0x17, 0x0a, + 0xf1, 0x90, 0x32, 0x9c, 0x10, 0x47, 0xb9, 0x62, 0xf9, 0xfa, 0x1c, 0x5f, 0x30, 0xa7, 0xf3, 0x56, + 0x1c, 0x9c, 0x3c, 0xe8, 0x9e, 0xd3, 0xe5, 0x81, 0x09, 0x18, 0x9e, 0xe7, 0x6f, 0xcc, 0x19, 0xe7, + 0x4a, 0x3d, 0x60, 0x45, 0xc7, 0xbf, 0x39, 0xa7, 0xdb, 0x4d, 0xcb, 0xcd, 0xc6, 0xb6, 0x7a, 0xe7, + 0xd7, 0x67, 0x2f, 0x9a, 0x33, 0x12, 0x40, 0xd4, 0x8d, 0x33, 0xe1, 0x74, 0xbf, 0x38, 0x0e, 0xc3, + 0x7c, 0x20, 0x9d, 0x8d, 0x5f, 0xd2, 0x1b, 0x19, 0x06, 0xed, 0xfd, 0xd6, 0x5c, 0xd8, 0x1c, 0x11, + 0x6f, 0x4e, 0xe9, 0xa7, 0xc1, 0xcb, 0x5e, 0xbb, 0x4a, 0x57, 0xbe, 0xd9, 0x4b, 0xe7, 0xc2, 0x9e, + 0x96, 0x00, 0xe7, 0x80, 0xf2, 0x46, 0xde, 0x6f, 0x1b, 0x60, 0xfc, 0x28, 0x4e, 0x70, 0x05, 0xdd, + 0x69, 0x4c, 0xd3, 0xf3, 0xdc, 0xec, 0x65, 0x86, 0x0c, 0x01, 0xfb, 0x42, 0xb8, 0xb2, 0x20, 0x8f, + 0x2f, 0x39, 0xb5, 0x1d, 0xf6, 0xb8, 0xb1, 0x88, 0x48, 0xbd, 0x5a, 0xc4, 0xcb, 0xe7, 0x0c, 0x4f, + 0xbd, 0x13, 0x8d, 0xab, 0xfe, 0x8e, 0x41, 0x70, 0x31, 0x10, 0xc1, 0x19, 0x7d, 0xdc, 0x46, 0x72, + 0x29, 0xc0, 0x77, 0x40, 0xc7, 0xf2, 0x2b, 0xe7, 0x8c, 0x03, 0xc2, 0x5e, 0xc0, 0x32, 0x36, 0xd1, + 0xbb, 0x6b, 0x6e, 0x19, 0xeb, 0x5d, 0xbf, 0xaa, 0x77, 0xd7, 0x3a, 0xb0, 0xe8, 0xfa, 0xd5, 0x06, + 0x26, 0xb9, 0x73, 0x9e, 0xdb, 0x68, 0x01, 0x35, 0xd3, 0xbb, 0x3b, 0xec, 0xf7, 0xe2, 0x68, 0x5e, + 0x9f, 0xa8, 0x1c, 0xf6, 0x35, 0x71, 0x9c, 0x69, 0x02, 0x8a, 0x21, 0x5f, 0xdb, 0x8b, 0xd5, 0xcd, + 0x0e, 0x5f, 0x17, 0x47, 0x88, 0x3a, 0x98, 0x3c, 0xe9, 0x9f, 0xd3, 0xad, 0x1b, 0x63, 0x60, 0x7e, + 0xf0, 0x8a, 0xf6, 0xa0, 0x6e, 0x0e, 0xbd, 0x61, 0x2e, 0x71, 0xdc, 0xba, 0xfb, 0xaa, 0x1a, 0x88, + 0x21, 0x7e, 0xdf, 0x90, 0xb3, 0x1c, 0x49, 0x95, 0xae, 0x8f, 0x0f, 0xd3, 0xb8, 0x75, 0xf6, 0x07, + 0x73, 0xa6, 0x47, 0xa4, 0xbe, 0xac, 0x03, 0x74, 0x97, 0xc6, 0x4f, 0x1a, 0xb0, 0x37, 0xf6, 0xde, + 0x12, 0xd4, 0x35, 0x7c, 0x5b, 0x94, 0x44, 0x78, 0x93, 0xc1, 0x59, 0xbd, 0xa1, 0xc5, 0xe4, 0xde, + 0x3c, 0xd7, 0x33, 0x25, 0x48, 0x4d, 0xe0, 0x2d, 0x71, 0xc2, 0x50, 0xef, 0x32, 0x20, 0x9f, 0xb7, + 0xc6, 0xc9, 0xae, 0x30, 0xa8, 0x4c, 0x19, 0xe8, 0xbd, 0xae, 0x4c, 0xdb, 0x59, 0xef, 0x84, 0x32, + 0x08, 0xe6, 0x7a, 0xda, 0x11, 0x1a, 0x34, 0x7b, 0xfb, 0x15, 0x3a, 0x95, 0xf2, 0x45, 0x24, 0x15, + 0xf4, 0x46, 0x96, 0x01, 0x2d, 0x13, 0x0c, 0x7a, 0x23, 0x82, 0xd4, 0x59, 0x77, 0x5b, 0x4d, 0xf7, + 0x1d, 0xbd, 0x11, 0x11, 0x80, 0x8a, 0x6e, 0xff, 0xb8, 0x97, 0xb2, 0x29, 0x7b, 0x98, 0xab, 0x5a, + 0xb9, 0xec, 0xc8, 0xe7, 0xb2, 0xd8, 0x3b, 0xe3, 0xba, 0x0d, 0x83, 0x8a, 0x6e, 0xff, 0xa4, 0x17, + 0xa7, 0x70, 0x58, 0xd9, 0xe5, 0x9f, 0xf6, 0xe2, 0x14, 0x09, 0x26, 0xba, 0xfb, 0x33, 0x43, 0x55, + 0x47, 0x9f, 0x51, 0x63, 0x7f, 0x6e, 0xcc, 0x4d, 0x97, 0xe9, 0xf4, 0x98, 0x25, 0xb7, 0x7d, 0xf9, + 0xb3, 0x9f, 0xec, 0x5d, 0x71, 0xdb, 0x14, 0x0c, 0x9a, 0xaa, 0xd7, 0xf1, 0x42, 0xb5, 0x9c, 0xe2, + 0xbb, 0xe3, 0xb6, 0x29, 0x06, 0x5a, 0xcc, 0xf4, 0x2f, 0xb4, 0x15, 0x95, 0xc0, 0x15, 0x04, 0x7e, + 0x73, 0xeb, 0xe2, 0x26, 0xba, 0x7c, 0xbb, 0x2d, 0xd3, 0xdc, 0x60, 0x7f, 0x19, 0xc7, 0xfb, 0xe2, + 0x30, 0xb9, 0xe1, 0x83, 0x89, 0x5e, 0x73, 0x9a, 0x46, 0xf0, 0xfa, 0xaf, 0xe2, 0x78, 0x3f, 0xbe, + 0x81, 0x8c, 0xd8, 0x18, 0x7b, 0x10, 0x79, 0xd5, 0x53, 0x3a, 0x88, 0x7f, 0x6d, 0xa0, 0x83, 0xb8, + 0x8f, 0x23, 0x35, 0xee, 0x41, 0x6e, 0xf6, 0x37, 0xbd, 0x36, 0xb6, 0x8a, 0xd1, 0x69, 0x35, 0xdb, + 0xf7, 0xf4, 0xda, 0x58, 0x09, 0x26, 0x13, 0x43, 0x7a, 0xd1, 0x14, 0xc1, 0xf1, 0x28, 0x9b, 0xec, + 0xf3, 0x6f, 0xe3, 0x74, 0x49, 0x04, 0x56, 0x74, 0xfc, 0xbe, 0xb9, 0x48, 0xb8, 0xa9, 0xed, 0xe0, + 0x6b, 0x00, 0xfa, 0x09, 0x30, 0xfb, 0x3b, 0x83, 0xfa, 0x77, 0x7b, 0x7a, 0x92, 0xbd, 0x7f, 0x2e, + 0x1c, 0x6b, 0xa3, 0x0e, 0x75, 0xfa, 0xa2, 0x2e, 0x3f, 0x60, 0x74, 0xc9, 0x63, 0x23, 0x14, 0xb9, + 0xaf, 0x5e, 0x6e, 0xe0, 0x99, 0x6f, 0xc3, 0xbd, 0x0c, 0xf6, 0x08, 0x85, 0xa0, 0x3f, 0x38, 0x17, + 0x17, 0xef, 0x69, 0x88, 0xd3, 0xe1, 0xd4, 0x3a, 0xe8, 0x6a, 0xcc, 0xfd, 0xf0, 0xd9, 0x87, 0x0c, + 0x62, 0xe9, 0x0d, 0x18, 0x44, 0xa9, 0x22, 0xec, 0xc0, 0xb7, 0x54, 0x7c, 0x75, 0xc9, 0x6d, 0xb5, + 0x60, 0xea, 0x3c, 0xef, 0x8c, 0xfd, 0x43, 0xdc, 0x2c, 0xe2, 0x00, 0xff, 0x31, 0x6e, 0x16, 0x31, + 0x80, 0x6a, 0x16, 0xff, 0x34, 0x67, 0x78, 0xfb, 0xa1, 0x44, 0x69, 0xfd, 0x88, 0x8a, 0x6f, 0xf0, + 0x3f, 0x1b, 0x03, 0xec, 0x06, 0x2f, 0x06, 0xf8, 0xb0, 0xb6, 0x27, 0x94, 0x05, 0x15, 0x44, 0x44, + 0xb8, 0x1e, 0x13, 0xd2, 0xe1, 0x23, 0x9a, 0xf8, 0x40, 0xb8, 0x14, 0xee, 0x96, 0xf6, 0x52, 0x30, + 0xfb, 0x68, 0x08, 0x80, 0x3f, 0x6d, 0xc6, 0x21, 0xd0, 0x51, 0x66, 0x1f, 0xd3, 0x90, 0x14, 0x07, + 0xa0, 0xa6, 0xf4, 0x71, 0xcd, 0x94, 0xa5, 0x1c, 0x74, 0xb7, 0xa3, 0x0f, 0xf4, 0x2f, 0x1a, 0xfb, + 0x44, 0xab, 0x55, 0x2f, 0x9f, 0x98, 0x0b, 0x1f, 0x17, 0x20, 0x12, 0xbc, 0x6e, 0x27, 0x32, 0xf3, + 0x4f, 0xcd, 0x05, 0x3e, 0x3e, 0x65, 0xed, 0x83, 0x66, 0xe7, 0xb6, 0x40, 0x99, 0x7f, 0x96, 0xd6, + 0x67, 0x9f, 0xd1, 0x58, 0x01, 0x41, 0xcc, 0x6a, 0x15, 0xfd, 0x0a, 0xcd, 0x2c, 0x0c, 0x25, 0x83, + 0x5f, 0xda, 0x1e, 0x45, 0xc0, 0x54, 0x94, 0xdd, 0xdd, 0xee, 0x64, 0xdc, 0x1a, 0xbe, 0x77, 0xc7, + 0x3e, 0x6b, 0x90, 0x17, 0xd9, 0x18, 0x79, 0xfa, 0x20, 0x8a, 0xca, 0x8e, 0xc3, 0x03, 0xdb, 0xed, + 0x0e, 0xfb, 0x9c, 0xe6, 0xf4, 0xf1, 0x9e, 0x41, 0xc0, 0x36, 0x2e, 0x75, 0x7d, 0x94, 0x59, 0xd9, + 0xa6, 0xb3, 0xed, 0x83, 0xc5, 0xf2, 0x79, 0xc3, 0x33, 0x54, 0x5c, 0xc8, 0x2f, 0x63, 0xe5, 0xc1, + 0x7a, 0xc0, 0x39, 0x7e, 0x21, 0xd4, 0x13, 0x72, 0x0a, 0x57, 0x7f, 0x38, 0x9c, 0xa0, 0x89, 0x2f, + 0x6b, 0xe6, 0xa3, 0xa4, 0x1d, 0x11, 0xf7, 0xa6, 0xf3, 0xf4, 0xaf, 0xc4, 0xd0, 0x96, 0x56, 0xaf, + 0x10, 0xf2, 0xef, 0xc6, 0x8c, 0x82, 0x47, 0xff, 0x30, 0x61, 0x47, 0xbe, 0x73, 0xce, 0xbe, 0x6a, + 0x58, 0x3a, 0x01, 0x90, 0x1e, 0x7c, 0xfe, 0x5a, 0x8f, 0x8e, 0x8c, 0xf0, 0xf3, 0xd7, 0x43, 0x7b, + 0xa9, 0x38, 0x50, 0x3f, 0x63, 0x64, 0xdf, 0xd0, 0x44, 0x7a, 0x4f, 0xa8, 0x20, 0x7b, 0x25, 0x22, + 0x2a, 0xb5, 0xa3, 0x51, 0xd0, 0x6f, 0xb4, 0x67, 0xec, 0x9b, 0x11, 0x31, 0xa1, 0x41, 0xf1, 0x84, + 0x27, 0x0e, 0xf8, 0xad, 0xb9, 0x70, 0x28, 0x39, 0x02, 0x98, 0x6a, 0x36, 0x11, 0xb6, 0x01, 0xa2, + 0xed, 0xdb, 0x11, 0xb1, 0xaa, 0x41, 0xd3, 0x9f, 0xfc, 0x15, 0x93, 0xef, 0x18, 0xc2, 0x3f, 0x90, + 0x68, 0x04, 0xb2, 0xea, 0xb4, 0x40, 0x93, 0xa1, 0x54, 0xe7, 0x4e, 0xff, 0x77, 0x23, 0x73, 0xd5, + 0x80, 0xb5, 0x23, 0x5f, 0xf6, 0xbd, 0x39, 0xf3, 0x50, 0x83, 0x27, 0xb1, 0x94, 0xb4, 0xec, 0xe3, + 0xef, 0xcf, 0x19, 0xc7, 0x0d, 0x06, 0x84, 0xc0, 0xdf, 0x0f, 0x42, 0x34, 0xc9, 0x41, 0xf0, 0xe5, + 0x5b, 0xaf, 0xe9, 0xe2, 0x53, 0x47, 0xe0, 0x0b, 0xb3, 0x1f, 0xc6, 0xa8, 0x05, 0x9c, 0x92, 0x49, + 0x9b, 0xa4, 0x62, 0x7f, 0x6c, 0x84, 0x2c, 0xf4, 0xa7, 0x5d, 0xd9, 0x4f, 0xe7, 0x62, 0x0e, 0xce, + 0xd4, 0x2b, 0xac, 0xec, 0x91, 0x64, 0x4c, 0xda, 0x6f, 0xe4, 0x91, 0x56, 0xf6, 0x94, 0x64, 0x98, + 0x89, 0x84, 0xe6, 0x93, 0x4f, 0xe7, 0x62, 0x0a, 0xf1, 0x53, 0x93, 0xfa, 0xc2, 0xf5, 0x54, 0x4d, + 0x25, 0x32, 0x1e, 0x4d, 0xea, 0x54, 0x1d, 0x02, 0x11, 0x63, 0x3d, 0x2d, 0x32, 0xd6, 0x2a, 0x3e, + 0x2d, 0xb7, 0x63, 0xe4, 0xf4, 0xff, 0x72, 0x32, 0x4c, 0x81, 0xc0, 0x3d, 0x05, 0xf7, 0xb2, 0xd1, + 0x25, 0x7b, 0x2c, 0x69, 0x6e, 0x05, 0x41, 0xe5, 0x7c, 0xfd, 0x04, 0xe5, 0xe9, 0xc9, 0x50, 0x94, + 0x5c, 0xd6, 0xf0, 0xc3, 0xeb, 0x5f, 0x49, 0x86, 0x5d, 0x79, 0x14, 0x97, 0x11, 0xb0, 0x67, 0x24, + 0x75, 0xa7, 0x29, 0xf4, 0xde, 0x2c, 0x7b, 0x66, 0x52, 0xdf, 0x49, 0x63, 0x8a, 0xab, 0x4e, 0xfb, + 0x22, 0xe6, 0x05, 0xa9, 0x4b, 0x11, 0xc9, 0x98, 0x80, 0xa1, 0xb0, 0xbb, 0x30, 0x95, 0xf0, 0xd9, + 0xc9, 0x98, 0x38, 0x97, 0xa8, 0x57, 0x58, 0xfe, 0xd5, 0x64, 0x4c, 0x14, 0x2a, 0x00, 0x12, 0x78, + 0x7e, 0x4e, 0x32, 0xc6, 0x38, 0x52, 0x26, 0x8c, 0xba, 0x8d, 0xc0, 0xbb, 0xfc, 0xb5, 0x64, 0x8c, + 0x05, 0x1c, 0x05, 0x16, 0x5d, 0x3f, 0xd7, 0xd8, 0x66, 0x25, 0x73, 0x05, 0x5e, 0x78, 0xf4, 0xe3, + 0x79, 0x06, 0xca, 0x48, 0x41, 0x69, 0x01, 0x9c, 0x5f, 0x4f, 0xea, 0xe6, 0xc8, 0xae, 0x8f, 0xf2, + 0xb2, 0x17, 0x18, 0x0b, 0xd9, 0xfd, 0x35, 0x5d, 0xf6, 0xc2, 0x64, 0x58, 0x4f, 0xe6, 0x5a, 0x35, + 0xfe, 0xad, 0xd0, 0x72, 0xf0, 0x55, 0xf6, 0x4a, 0xa6, 0xc8, 0x7e, 0x23, 0x19, 0xb6, 0x88, 0xe2, + 0x20, 0xf3, 0x78, 0x5b, 0x92, 0xfd, 0x66, 0x52, 0xf7, 0x36, 0x04, 0x7a, 0xb8, 0xe4, 0xa2, 0x60, + 0x27, 0x7b, 0x51, 0x32, 0x26, 0xb4, 0xa0, 0x01, 0x04, 0xb7, 0x3e, 0x8c, 0xf9, 0xc9, 0x90, 0x69, + 0xf0, 0x64, 0x7b, 0x70, 0xf5, 0xe3, 0x25, 0x49, 0xdd, 0xbc, 0xdf, 0x05, 0x32, 0x08, 0x63, 0x45, + 0xb6, 0x05, 0x89, 0x59, 0x48, 0x15, 0x9e, 0x26, 0xc3, 0x5e, 0x6a, 0x20, 0x33, 0x5e, 0x39, 0x05, + 0x17, 0x4a, 0x0c, 0x6a, 0x8d, 0xc6, 0xd7, 0x5e, 0x96, 0xd4, 0x73, 0xdc, 0x82, 0x7a, 0xf6, 0xb8, + 0xc1, 0x75, 0x41, 0x05, 0xbf, 0x63, 0xc1, 0x5e, 0x9e, 0x8c, 0xe6, 0xd5, 0x06, 0xd5, 0x41, 0x2a, + 0x4c, 0x32, 0x26, 0x89, 0x42, 0xe6, 0x62, 0xd0, 0xbe, 0xbc, 0x22, 0x19, 0x93, 0x44, 0xa1, 0x43, + 0xa8, 0xbe, 0x5e, 0x19, 0x25, 0x59, 0x05, 0x29, 0x1c, 0x47, 0xf6, 0xbb, 0x11, 0x8a, 0x88, 0xc0, + 0x04, 0x97, 0x4b, 0x76, 0xeb, 0x4f, 0xe4, 0xa2, 0xbc, 0x7a, 0xb7, 0xfe, 0x42, 0x19, 0x8d, 0xbf, + 0xa7, 0xad, 0x44, 0x28, 0xe8, 0x73, 0xae, 0x7b, 0x11, 0x36, 0x87, 0x1c, 0x14, 0x57, 0x31, 0x23, + 0x7b, 0x4d, 0xd2, 0x34, 0xcb, 0x7a, 0x80, 0xbd, 0xd6, 0xd8, 0x68, 0x0c, 0x03, 0xe1, 0xb7, 0x04, + 0x82, 0x48, 0xea, 0xaa, 0xa7, 0x39, 0x67, 0xaf, 0x33, 0xd8, 0xbf, 0x27, 0xb0, 0x8c, 0x52, 0x19, + 0xf2, 0xce, 0x84, 0x46, 0x6f, 0xb1, 0x11, 0x74, 0xfc, 0x06, 0x03, 0x05, 0x3d, 0x40, 0x65, 0x64, + 0xca, 0x90, 0xe6, 0x0f, 0x76, 0x1b, 0xb5, 0x8b, 0x74, 0x0b, 0x52, 0x01, 0xef, 0xb0, 0x3f, 0x30, + 0x46, 0x8e, 0x03, 0x09, 0x2e, 0xa9, 0x24, 0x63, 0xbd, 0xb3, 0xc0, 0x52, 0x4e, 0x71, 0x43, 0xec, + 0x4d, 0x1a, 0x6b, 0xab, 0x8c, 0x55, 0xdd, 0x9e, 0x7e, 0xb3, 0xc6, 0xda, 0x71, 0x00, 0x6a, 0xc4, + 0xb7, 0x68, 0x23, 0x0a, 0x40, 0x1c, 0xb1, 0xd2, 0x85, 0x3f, 0x77, 0xb4, 0x34, 0xbd, 0xb7, 0x26, + 0x03, 0x27, 0x68, 0x17, 0xb8, 0x20, 0x32, 0x95, 0x0c, 0x67, 0x1c, 0x01, 0xf1, 0x5c, 0x6a, 0xd4, + 0x5d, 0xde, 0x42, 0x64, 0xd5, 0xfe, 0x61, 0x32, 0x6c, 0xe1, 0x50, 0xc4, 0x2c, 0xe0, 0x6f, 0x69, + 0x79, 0xbe, 0x3d, 0xa2, 0x7f, 0x45, 0xda, 0x46, 0xee, 0x01, 0x3c, 0xe9, 0x7d, 0x90, 0x67, 0xee, + 0x24, 0x7b, 0x9b, 0xa7, 0x3c, 0x6e, 0x5d, 0x67, 0xef, 0x48, 0x9a, 0x1e, 0x90, 0x19, 0x7d, 0x6c, + 0xb4, 0x94, 0xd2, 0xfb, 0xe3, 0x10, 0x6d, 0xc7, 0x00, 0xca, 0xab, 0x2d, 0x49, 0xdd, 0xd0, 0xd1, + 0xbf, 0xb5, 0xc0, 0xfe, 0xc4, 0xd0, 0x27, 0xa1, 0x2f, 0x29, 0xb0, 0x3f, 0x35, 0x68, 0x27, 0xee, + 0x1b, 0x03, 0xec, 0xcf, 0x0c, 0x59, 0xb1, 0xcb, 0x67, 0x08, 0xd8, 0x9f, 0x27, 0xc3, 0x96, 0x59, + 0x2c, 0xe9, 0x40, 0x2d, 0x7b, 0x97, 0xb6, 0xe7, 0xc1, 0xeb, 0x82, 0xd5, 0xb6, 0x53, 0xbb, 0x98, + 0x69, 0x38, 0x4d, 0x6f, 0x43, 0xec, 0xce, 0xbb, 0x93, 0xf1, 0x07, 0x8a, 0xd2, 0xd4, 0x93, 0xa8, + 0xfa, 0x8b, 0x64, 0x7c, 0x88, 0x3a, 0x80, 0x93, 0x09, 0x3c, 0x71, 0x92, 0x2f, 0x66, 0xbb, 0x7d, + 0xf6, 0x57, 0x86, 0x1e, 0xd9, 0x05, 0x32, 0x08, 0x13, 0x69, 0xeb, 0x0f, 0x2e, 0x01, 0x8b, 0x04, + 0x57, 0xba, 0xa0, 0x25, 0xdf, 0xd1, 0x60, 0x7f, 0x1d, 0xa2, 0x3a, 0x89, 0x03, 0x3d, 0xa6, 0x82, + 0xd1, 0x30, 0xf6, 0x37, 0x1a, 0x11, 0x57, 0x1e, 0xcc, 0xd3, 0x37, 0xe7, 0xdc, 0xba, 0x66, 0x36, + 0x10, 0xd4, 0x7b, 0xa2, 0xbc, 0x26, 0xa8, 0xb3, 0x22, 0xbf, 0xa2, 0x48, 0x11, 0x05, 0xf6, 0xde, + 0x64, 0x10, 0x83, 0x23, 0x27, 0x17, 0xaf, 0x10, 0x67, 0x60, 0xff, 0x76, 0x90, 0x86, 0xb5, 0x47, + 0x15, 0x45, 0xa0, 0x28, 0x19, 0x13, 0xb2, 0xd3, 0x4e, 0xbb, 0x42, 0xe9, 0x58, 0xef, 0x4b, 0xea, + 0x61, 0x8a, 0x5d, 0xc0, 0xe5, 0x5d, 0xa3, 0x64, 0xf8, 0xdc, 0x50, 0xbe, 0xa1, 0xba, 0xd6, 0x6a, + 0x7a, 0xb5, 0x8b, 0xec, 0xfd, 0xc9, 0xe0, 0xac, 0x4b, 0x04, 0x2f, 0x28, 0xa2, 0x4b, 0xca, 0xf2, + 0x03, 0xda, 0x56, 0x06, 0x34, 0x24, 0x7b, 0xd0, 0x1d, 0xc2, 0x0f, 0x86, 0xec, 0x5d, 0x71, 0x71, + 0x4a, 0x83, 0x64, 0x1f, 0x4a, 0x26, 0x16, 0xad, 0x64, 0x6c, 0x04, 0xbd, 0x4a, 0x6f, 0x68, 0x87, + 0x63, 0x78, 0x69, 0xf9, 0x8d, 0x5f, 0x11, 0xb2, 0xfe, 0xfb, 0x64, 0xd8, 0x59, 0xe3, 0x26, 0x9b, + 0xa9, 0x66, 0xe4, 0x8c, 0xfe, 0x21, 0x19, 0x3e, 0x39, 0x8b, 0x87, 0x16, 0x88, 0xfa, 0xc7, 0x88, + 0x46, 0xe4, 0xe0, 0x94, 0xfb, 0xdd, 0xa8, 0xd1, 0xd9, 0x9f, 0xec, 0xfa, 0xc3, 0xc9, 0xb0, 0x7f, + 0x17, 0x07, 0x2b, 0x3a, 0xfe, 0x88, 0xa6, 0x14, 0x81, 0xbc, 0xf8, 0x15, 0xec, 0x62, 0x2b, 0x34, + 0x0f, 0xf6, 0xd1, 0x58, 0x54, 0x63, 0x4e, 0xa2, 0xf9, 0xfe, 0xbe, 0xcf, 0x3e, 0x16, 0x0b, 0xb9, + 0x12, 0x03, 0xf9, 0x71, 0x8d, 0xbf, 0x76, 0x85, 0x0c, 0x52, 0xab, 0xb4, 0xbe, 0x03, 0xfe, 0x8a, + 0xeb, 0xfb, 0x13, 0x5a, 0xdf, 0xbb, 0x42, 0x06, 0x6f, 0x0c, 0x68, 0x12, 0xd4, 0x7c, 0x92, 0x9f, + 0x7d, 0x2a, 0x69, 0x06, 0x86, 0xa2, 0xaf, 0xf5, 0xb3, 0x4f, 0xeb, 0x33, 0x7b, 0x30, 0xaf, 0x09, + 0x3f, 0x70, 0xd0, 0x91, 0xb3, 0x40, 0xf3, 0x6c, 0xb4, 0xd1, 0xbc, 0xff, 0x9f, 0x1a, 0xa7, 0x9a, + 0xab, 0x0e, 0x01, 0x7e, 0x26, 0x19, 0x84, 0x87, 0x76, 0x03, 0x0c, 0x5e, 0x38, 0x88, 0xe8, 0xa7, + 0x15, 0xb4, 0x4d, 0x71, 0xf1, 0xcb, 0xc0, 0xfe, 0xd4, 0x05, 0xfb, 0xb7, 0x08, 0x71, 0x44, 0x81, + 0x82, 0x7b, 0x53, 0x1a, 0xd5, 0xc1, 0xaa, 0x84, 0x6b, 0x6b, 0x5e, 0x54, 0x12, 0xdf, 0x5a, 0x64, + 0x9f, 0xd3, 0x14, 0x1f, 0x62, 0x80, 0x42, 0xc4, 0xf4, 0xec, 0x73, 0xd5, 0x13, 0xa6, 0x1b, 0xfb, + 0xbc, 0x06, 0x63, 0x2c, 0x89, 0x03, 0x92, 0x4f, 0xf8, 0x05, 0x6d, 0xcc, 0x1e, 0x30, 0x6a, 0x7e, + 0x5f, 0x0c, 0xd9, 0x92, 0x02, 0x9e, 0x00, 0x53, 0xfc, 0x12, 0x06, 0xfb, 0x92, 0x61, 0x0b, 0xe3, + 0x8c, 0x97, 0xbc, 0x8e, 0xf1, 0x08, 0xc5, 0x97, 0x93, 0x7a, 0x3a, 0x50, 0x0c, 0x44, 0x34, 0xbc, + 0xfa, 0x15, 0x8d, 0x58, 0x04, 0xd0, 0x92, 0xc7, 0x85, 0xd2, 0xbf, 0xf7, 0xb0, 0x12, 0xb4, 0xc7, + 0xac, 0x7d, 0xf6, 0x55, 0x0d, 0xc8, 0x58, 0xa4, 0x06, 0xc5, 0xbe, 0xa6, 0x6d, 0x55, 0x2f, 0xa0, + 0x20, 0x9a, 0xa5, 0xf5, 0x68, 0x10, 0xbc, 0xde, 0xe3, 0x37, 0xb4, 0x1e, 0x7b, 0x01, 0x05, 0xb1, + 0xac, 0x5e, 0x2c, 0xaf, 0x01, 0xe3, 0xd3, 0x07, 0x3e, 0xfb, 0x66, 0xac, 0x2e, 0xd3, 0xc0, 0xc4, + 0x23, 0xd2, 0xec, 0x5b, 0x11, 0x2d, 0x85, 0x5d, 0x9e, 0xa5, 0x2f, 0x3c, 0xec, 0x94, 0xda, 0x6e, + 0xbd, 0x21, 0x54, 0xef, 0xb7, 0x35, 0xe9, 0x18, 0x8c, 0x8d, 0x31, 0x01, 0x3d, 0x48, 0xc0, 0x69, + 0xc1, 0xa9, 0xb3, 0xef, 0x86, 0xec, 0x0e, 0xf5, 0x90, 0xb5, 0x0e, 0x0d, 0x9c, 0x0f, 0x53, 0xf8, + 0x5e, 0xec, 0x14, 0xf0, 0x1c, 0xb7, 0x51, 0xc3, 0xaf, 0x46, 0xa2, 0x85, 0x72, 0xa9, 0xd1, 0xd9, + 0x61, 0xdf, 0xd7, 0x8d, 0x52, 0xbe, 0xc5, 0x18, 0x80, 0xea, 0xb6, 0x44, 0x77, 0x95, 0xee, 0xd6, + 0x96, 0x03, 0xe6, 0xd5, 0x0f, 0x62, 0x71, 0x6a, 0x3c, 0xfc, 0x61, 0x2b, 0x9c, 0xfe, 0x30, 0x19, + 0xbe, 0xbc, 0x1b, 0x88, 0xe7, 0xe0, 0xab, 0x6e, 0xec, 0x47, 0x21, 0x26, 0xe5, 0xa0, 0x01, 0x80, + 0x3a, 0xfc, 0x46, 0x0b, 0xe9, 0xc7, 0x86, 0x85, 0x84, 0xe0, 0xf9, 0x54, 0x81, 0xcf, 0xc4, 0xb8, + 0x39, 0xfe, 0x1f, 0xd1, 0x05, 0xa5, 0x7c, 0x1f, 0x1f, 0x7c, 0x69, 0xad, 0x36, 0x5a, 0x0d, 0x15, + 0x33, 0xfb, 0x49, 0x2c, 0x86, 0x80, 0x48, 0x72, 0xf4, 0x29, 0x54, 0x32, 0xe6, 0x48, 0x63, 0xfe, + 0x34, 0x19, 0x3e, 0xc4, 0xe0, 0xfb, 0x1c, 0x82, 0x53, 0x7a, 0x93, 0x3d, 0x32, 0x6f, 0xea, 0x3c, + 0xde, 0x7b, 0x08, 0xdc, 0x2e, 0x82, 0xea, 0x6d, 0xba, 0xa5, 0x14, 0x7b, 0xca, 0x7c, 0x9c, 0xb4, + 0xe7, 0xa9, 0x22, 0xf8, 0xca, 0x18, 0xdf, 0x01, 0x8c, 0x7c, 0x3e, 0x75, 0x3e, 0x1c, 0xf4, 0x8a, + 0x83, 0x7a, 0x74, 0x3e, 0x3e, 0x94, 0xa9, 0x63, 0x01, 0xa7, 0xc2, 0x9e, 0x36, 0x1f, 0xf6, 0x80, + 0x62, 0x3f, 0x89, 0xc5, 0x7e, 0x79, 0x3e, 0x4e, 0x54, 0x95, 0xe9, 0x2b, 0xa2, 0x9a, 0x9d, 0x48, + 0xf6, 0xde, 0x63, 0xf3, 0xba, 0xd9, 0xa9, 0xe7, 0x1c, 0x86, 0xaf, 0x76, 0x3e, 0x7d, 0x3e, 0x3e, + 0x91, 0x31, 0x26, 0x8b, 0xee, 0x57, 0xe6, 0xc3, 0xb6, 0xac, 0x71, 0x36, 0xa5, 0x31, 0xd4, 0x33, + 0xe6, 0xcd, 0x70, 0x9d, 0x88, 0xbd, 0x2a, 0x08, 0x41, 0x4b, 0xcf, 0x9c, 0x8f, 0x53, 0x9b, 0xfa, + 0x81, 0x49, 0xa0, 0x3f, 0xd1, 0xee, 0xf4, 0xd9, 0xb3, 0xe6, 0xc3, 0x56, 0xcf, 0x6e, 0xd0, 0xcf, + 0x9e, 0x8f, 0x93, 0x14, 0xb4, 0xf7, 0x9c, 0x55, 0xa4, 0x8b, 0xf4, 0xab, 0xf3, 0x7a, 0x1c, 0x24, + 0xfc, 0x45, 0x37, 0xf6, 0x9c, 0x79, 0x5d, 0xa8, 0xc7, 0x7c, 0xab, 0x8d, 0xfd, 0x5a, 0x64, 0x5e, + 0xfc, 0x5e, 0xce, 0xaa, 0xd7, 0x42, 0x64, 0x9e, 0x75, 0x9a, 0x8d, 0x3a, 0xf1, 0x10, 0x5d, 0xd6, + 0x79, 0xde, 0x7c, 0x60, 0x66, 0x86, 0xbf, 0x7d, 0xc9, 0x5e, 0x30, 0x1f, 0x0e, 0x75, 0xa2, 0x1f, + 0xa0, 0x5c, 0x7c, 0xee, 0x02, 0xf9, 0xec, 0x85, 0xf3, 0x61, 0x8b, 0x2e, 0x0e, 0x2c, 0xb8, 0x43, + 0x36, 0x6f, 0x5a, 0x74, 0xbb, 0x3c, 0xbe, 0xcf, 0x7e, 0x73, 0x3e, 0x1c, 0xae, 0x0d, 0xfa, 0x15, + 0xaf, 0xfc, 0xbf, 0x28, 0x42, 0xdc, 0x21, 0xd7, 0x0b, 0xd4, 0x36, 0xe5, 0xf2, 0xbc, 0x78, 0x3e, + 0xec, 0xa3, 0x55, 0x84, 0x57, 0xbe, 0xba, 0x5a, 0x72, 0x40, 0xba, 0x2d, 0x37, 0xbb, 0xfe, 0x26, + 0x1e, 0x14, 0xb1, 0x97, 0xe8, 0x58, 0xc6, 0xd7, 0x2e, 0x78, 0x34, 0xbe, 0xed, 0xf8, 0x9b, 0xe2, + 0x3d, 0x84, 0xdf, 0xd2, 0x09, 0x30, 0x0e, 0x22, 0xb8, 0x56, 0x16, 0x22, 0x55, 0x91, 0x3f, 0xd3, + 0x11, 0xd7, 0xfb, 0x37, 0xc0, 0x92, 0x16, 0xee, 0xe6, 0x6f, 0xcf, 0xc7, 0x1e, 0x37, 0xd3, 0x14, + 0x29, 0x24, 0xe8, 0x6f, 0x36, 0xb6, 0xd9, 0xcb, 0x22, 0xa4, 0x8f, 0x21, 0x3b, 0x61, 0x68, 0xf8, + 0xfa, 0xf6, 0x3d, 0xde, 0x83, 0x4b, 0x63, 0x9e, 0x92, 0x67, 0x2f, 0xd7, 0x60, 0x75, 0x91, 0x13, + 0x07, 0xfb, 0x3b, 0xc6, 0x06, 0xee, 0xfa, 0x34, 0x3d, 0x7b, 0x85, 0xb6, 0x3b, 0x42, 0xf6, 0xea, + 0x9c, 0x1a, 0x74, 0xfa, 0xca, 0xf9, 0x38, 0xc3, 0x00, 0x95, 0x6e, 0x70, 0xda, 0xc7, 0x7e, 0x77, + 0x3e, 0xce, 0x84, 0xe4, 0xa7, 0xf6, 0x04, 0x27, 0xb2, 0x83, 0xd8, 0xab, 0xe6, 0xa3, 0xc7, 0x51, + 0x3c, 0x19, 0x04, 0x93, 0x33, 0xa5, 0x55, 0xf6, 0x6a, 0x8d, 0x70, 0xa5, 0xe5, 0xa6, 0xa5, 0xb8, + 0x54, 0x3d, 0xbe, 0x31, 0xa7, 0xbd, 0x66, 0x1d, 0xdf, 0x90, 0x7a, 0xcd, 0x7c, 0x9c, 0xd9, 0x5e, + 0xd9, 0xc5, 0xb4, 0x7e, 0x6d, 0x84, 0xe4, 0x4c, 0x2f, 0xaf, 0xe0, 0x95, 0x01, 0x77, 0xf8, 0x32, + 0x24, 0x7b, 0x5d, 0x2c, 0xaf, 0x29, 0x59, 0x2a, 0x6f, 0x6a, 0xbf, 0x5e, 0x5b, 0x58, 0xb0, 0x4f, + 0x38, 0x43, 0x7d, 0xe7, 0xdf, 0xa0, 0x2b, 0x10, 0xf9, 0xa4, 0x18, 0xa5, 0x78, 0x07, 0x50, 0xd8, + 0xc6, 0x67, 0xbf, 0x3f, 0x1f, 0x36, 0xda, 0xf0, 0x8c, 0x12, 0x98, 0x11, 0x59, 0xa6, 0xe2, 0xf2, + 0xf0, 0xd3, 0x1f, 0xcc, 0x87, 0xc3, 0x49, 0xc6, 0xbd, 0x92, 0x0a, 0x7d, 0x8f, 0x9a, 0xbd, 0x51, + 0x13, 0x3c, 0x3d, 0xa1, 0x14, 0x6a, 0xde, 0x34, 0x1f, 0xe8, 0x50, 0xe5, 0x37, 0x08, 0x09, 0xaa, + 0xc7, 0x9f, 0x55, 0x74, 0xf2, 0xcd, 0x21, 0xb1, 0x21, 0x2f, 0xa8, 0x87, 0xb2, 0x4c, 0xf0, 0xc9, + 0x53, 0xf6, 0x96, 0xf9, 0x38, 0x6b, 0x83, 0x1e, 0x38, 0x58, 0x71, 0xb7, 0xf0, 0x6b, 0x60, 0x0d, + 0x8c, 0xde, 0xbe, 0x35, 0x9e, 0x9c, 0xc8, 0xc6, 0x40, 0xa9, 0xdc, 0xa8, 0x81, 0x4a, 0x6b, 0x6c, + 0xbb, 0xec, 0x6d, 0xf3, 0x71, 0x1e, 0x49, 0x14, 0x50, 0xad, 0xee, 0x0f, 0x7b, 0x61, 0x4c, 0xb8, + 0x30, 0xc5, 0x36, 0x92, 0xf3, 0xdb, 0x7b, 0x61, 0x4c, 0x87, 0x0a, 0xee, 0xd0, 0xcd, 0x1b, 0xf1, + 0x10, 0x4d, 0x42, 0x2c, 0xe1, 0xb7, 0x7c, 0xc4, 0xd6, 0xff, 0x51, 0x44, 0x85, 0x07, 0x11, 0x64, + 0x6e, 0xda, 0x73, 0xa7, 0xfd, 0x1d, 0xf3, 0xe1, 0x0b, 0x32, 0xb1, 0x70, 0x41, 0x8e, 0x97, 0xa1, + 0x97, 0x32, 0xee, 0x25, 0x9b, 0x86, 0x3e, 0xe7, 0xb4, 0xd1, 0xd6, 0x60, 0xef, 0x5e, 0xe8, 0x8d, + 0x4a, 0xfd, 0xcb, 0xb7, 0xec, 0x2f, 0x16, 0x4c, 0x65, 0x21, 0xd3, 0x9a, 0x02, 0x10, 0xc3, 0xc6, + 0xfb, 0xcb, 0x05, 0xcd, 0x4b, 0x57, 0xf4, 0x9e, 0x07, 0xde, 0x01, 0x3a, 0x6d, 0x53, 0xd6, 0x0e, + 0x9e, 0x69, 0xfe, 0xd5, 0x82, 0x19, 0xe1, 0x4e, 0x17, 0xce, 0x9f, 0x3c, 0x7e, 0xe2, 0x89, 0x01, + 0xb5, 0xaf, 0x51, 0x9a, 0xd2, 0xff, 0x88, 0x9d, 0xa5, 0x96, 0xea, 0x2d, 0xdd, 0x9c, 0xbf, 0x5e, + 0x88, 0x13, 0xda, 0x06, 0xa0, 0xc0, 0xcb, 0xdf, 0x2c, 0x18, 0x27, 0xee, 0xf8, 0x9e, 0x85, 0x19, + 0x42, 0xc1, 0x5b, 0x63, 0xef, 0x59, 0x08, 0xe4, 0x40, 0x30, 0x2e, 0xc6, 0x31, 0xab, 0xde, 0x76, + 0x85, 0xce, 0x64, 0xaa, 0x67, 0xf9, 0xd3, 0x4c, 0xef, 0x5d, 0xd0, 0x7d, 0x32, 0x39, 0x72, 0x1c, + 0x68, 0x70, 0xdf, 0x6d, 0xc1, 0x78, 0xd0, 0x44, 0x3d, 0x17, 0xf7, 0xbe, 0x05, 0xe3, 0x41, 0x93, + 0xc8, 0x3d, 0x97, 0xbf, 0x5b, 0x30, 0x9e, 0x81, 0x0b, 0x16, 0x67, 0x38, 0x89, 0xef, 0xd7, 0x26, + 0xa4, 0xed, 0xac, 0xa9, 0x86, 0x79, 0x8c, 0x4d, 0x62, 0xef, 0x03, 0x0b, 0x89, 0x93, 0xd6, 0xbd, + 0xe1, 0x35, 0xf4, 0x68, 0x22, 0x26, 0xf3, 0xc1, 0xd8, 0x61, 0x2a, 0x5e, 0xad, 0xe1, 0x34, 0x97, + 0x5d, 0xb7, 0x8e, 0xb7, 0x47, 0xf8, 0x27, 0x7f, 0xd4, 0x30, 0x1f, 0x8a, 0x1d, 0xa6, 0x47, 0x13, + 0x99, 0xd4, 0xb4, 0x10, 0x5c, 0x62, 0x88, 0x5b, 0x8d, 0xcf, 0x73, 0x51, 0xc4, 0x27, 0x84, 0x54, + 0xcc, 0x6a, 0x21, 0xf1, 0x44, 0xeb, 0x78, 0xef, 0x05, 0x85, 0x5b, 0xc9, 0xd8, 0xd5, 0x42, 0x70, + 0xf7, 0x41, 0xdb, 0x76, 0x1d, 0x36, 0xe8, 0x43, 0x8e, 0xf5, 0x4f, 0x0b, 0xc6, 0x4b, 0x3e, 0x92, + 0x00, 0x7a, 0x35, 0x12, 0x43, 0xfd, 0xf3, 0x42, 0x9c, 0xae, 0x97, 0xb7, 0x95, 0xf9, 0xd3, 0x32, + 0x2a, 0x4c, 0xb6, 0x10, 0xe7, 0x64, 0x85, 0x61, 0x65, 0x98, 0x6c, 0xc1, 0x0c, 0x54, 0x86, 0xbf, + 0xe5, 0xc2, 0x3e, 0xaa, 0xed, 0x42, 0x78, 0xe3, 0xf8, 0x87, 0xa5, 0xa3, 0x3b, 0xf7, 0xb1, 0x05, + 0xfd, 0x52, 0x88, 0xb9, 0x73, 0xd1, 0x36, 0x32, 0x2b, 0x6a, 0x21, 0x90, 0x58, 0xb1, 0x03, 0x85, + 0x42, 0xb2, 0xff, 0xb2, 0x60, 0x7a, 0x69, 0x91, 0x41, 0xc2, 0x31, 0xd9, 0x4f, 0x2c, 0x04, 0xc6, + 0x66, 0xd4, 0x04, 0xc1, 0x3b, 0x75, 0xec, 0x93, 0x0b, 0x71, 0x8a, 0x65, 0xd5, 0x6d, 0x6f, 0xb8, + 0x9a, 0xfd, 0xc1, 0x3e, 0xb5, 0x10, 0x67, 0xe2, 0x12, 0x18, 0x3d, 0xa4, 0x2a, 0xef, 0xfc, 0x82, + 0x3e, 0x62, 0x9f, 0x8e, 0x95, 0x49, 0x41, 0x97, 0xc1, 0x15, 0xc5, 0x05, 0xd3, 0xb0, 0xd7, 0x3a, + 0x35, 0x00, 0x79, 0xb7, 0x9f, 0x59, 0xe8, 0x11, 0x8d, 0xd4, 0x83, 0x18, 0xe4, 0xa0, 0xfd, 0xeb, + 0x42, 0x8f, 0x68, 0x64, 0x18, 0x32, 0xc8, 0xdf, 0x5a, 0x88, 0xd3, 0x5b, 0xf8, 0x32, 0x75, 0x60, + 0x3c, 0x05, 0xe4, 0xf6, 0xd9, 0x5e, 0xd0, 0x9c, 0xa6, 0x43, 0xd0, 0x9f, 0x8b, 0x5d, 0x65, 0x78, + 0x2a, 0xd2, 0x3f, 0xf8, 0xe2, 0x42, 0xfc, 0xe3, 0xa3, 0xfc, 0xe9, 0x64, 0xbe, 0xbe, 0x2f, 0x85, + 0xc8, 0x5d, 0x46, 0x08, 0x34, 0x18, 0x3a, 0x0b, 0xc0, 0x37, 0x3f, 0xd9, 0x97, 0x17, 0x62, 0xcc, + 0x30, 0xde, 0xc2, 0x57, 0x61, 0x42, 0x9f, 0x7d, 0x75, 0x21, 0xc6, 0xe5, 0x89, 0x80, 0x29, 0x84, + 0x7d, 0x6d, 0xa1, 0xe7, 0x13, 0x67, 0xf8, 0x48, 0x15, 0xbe, 0xad, 0x48, 0x7a, 0xe2, 0xeb, 0x0b, + 0x66, 0xbc, 0x55, 0xe4, 0x8b, 0xf1, 0x3c, 0x44, 0x7e, 0x8c, 0xf1, 0x0d, 0x4d, 0x95, 0xc4, 0x83, + 0x04, 0x71, 0xac, 0xab, 0x10, 0xa9, 0x22, 0x07, 0x44, 0x62, 0xff, 0x9b, 0x57, 0x21, 0x52, 0x55, + 0x13, 0xf9, 0xe8, 0x90, 0xc6, 0x67, 0x81, 0x70, 0x40, 0xd9, 0xe0, 0xb6, 0xc4, 0xeb, 0x40, 0x88, + 0x5e, 0xb7, 0x8e, 0x8f, 0xfa, 0xa0, 0xb2, 0xfe, 0xb6, 0x2e, 0xab, 0x82, 0x7b, 0x3a, 0x52, 0xd1, + 0x35, 0xfc, 0xcd, 0x00, 0xf6, 0x3b, 0x06, 0x13, 0x9b, 0xef, 0xae, 0x36, 0x3d, 0x3f, 0x72, 0x36, + 0xc1, 0xbe, 0x6b, 0xa0, 0x3a, 0xf2, 0x4e, 0xac, 0x9a, 0xf5, 0xf7, 0x34, 0x54, 0x2b, 0x6b, 0x8a, + 0x93, 0x15, 0x4a, 0xc0, 0xd5, 0xd5, 0x32, 0xfb, 0xfe, 0x42, 0x2f, 0x83, 0x4b, 0xbb, 0x93, 0xc3, + 0x7e, 0xb0, 0xd0, 0x3b, 0xe5, 0x80, 0x2e, 0xed, 0xb0, 0x1f, 0x2e, 0xf4, 0x4e, 0x39, 0x20, 0x08, + 0x35, 0xa9, 0x1f, 0x2d, 0x04, 0x27, 0x96, 0x42, 0xff, 0x9e, 0x03, 0x54, 0x8b, 0x6b, 0x68, 0x3f, + 0x8e, 0x37, 0x9d, 0x22, 0x6c, 0x27, 0x5f, 0x3c, 0xea, 0x05, 0x1e, 0xe2, 0x3b, 0x79, 0xcf, 0x31, + 0x56, 0x83, 0x08, 0x28, 0x8c, 0x10, 0x6d, 0x39, 0x2a, 0x8b, 0xfa, 0xa7, 0x0b, 0x71, 0x01, 0xda, + 0x30, 0xac, 0xe8, 0xf8, 0x91, 0xc5, 0x18, 0x8b, 0x54, 0x30, 0xb4, 0x6e, 0xb9, 0x3e, 0x65, 0x31, + 0xc6, 0x22, 0x8d, 0xc2, 0x05, 0x37, 0x29, 0x17, 0xe3, 0x42, 0x2a, 0xc8, 0x0f, 0x65, 0x77, 0x03, + 0x63, 0x3f, 0x59, 0xca, 0x1c, 0xa8, 0xb3, 0x47, 0x17, 0x03, 0xd3, 0x55, 0xb3, 0xfa, 0xf0, 0xd1, + 0x70, 0x8c, 0xe6, 0x3d, 0x6d, 0x31, 0x2e, 0xda, 0x16, 0xa7, 0x51, 0x7e, 0x79, 0xd1, 0x74, 0xe7, + 0x38, 0x74, 0xac, 0x2e, 0x79, 0x6c, 0x31, 0x2c, 0x47, 0xb2, 0x2d, 0x1f, 0xd4, 0xab, 0xbc, 0xe3, + 0xc8, 0x6f, 0x7a, 0xb3, 0xa7, 0x2f, 0x86, 0xe5, 0x48, 0x1c, 0x58, 0x10, 0xf6, 0x5a, 0x8c, 0x3b, + 0x3b, 0x0e, 0xd0, 0x24, 0x23, 0x32, 0xcf, 0x58, 0x8c, 0x53, 0x95, 0x11, 0xb8, 0xe0, 0x26, 0x65, + 0x2c, 0x2a, 0xa3, 0x0f, 0x7f, 0xb3, 0x67, 0x2d, 0xc6, 0xf9, 0x35, 0xa7, 0x4f, 0x9e, 0x7a, 0x60, + 0x0d, 0xe6, 0xbd, 0x8d, 0x81, 0x0f, 0x40, 0xf8, 0xb3, 0x17, 0xe3, 0x54, 0x9a, 0xc0, 0x22, 0x02, + 0x57, 0x38, 0x28, 0xfb, 0xd5, 0xc5, 0x38, 0x75, 0x0a, 0xf3, 0xa4, 0x94, 0x02, 0x75, 0x20, 0xf4, + 0x9c, 0xc5, 0xb8, 0xa0, 0x78, 0x18, 0x2c, 0x88, 0x80, 0x2d, 0x46, 0xce, 0x28, 0x1e, 0x2a, 0xa5, + 0x3d, 0xfc, 0x82, 0xe4, 0x73, 0x17, 0x4d, 0x77, 0x57, 0x5b, 0x28, 0x42, 0xba, 0x75, 0xb4, 0x78, + 0x9f, 0xb7, 0x68, 0x1c, 0x9c, 0xa8, 0xeb, 0xec, 0xea, 0x09, 0x73, 0xf6, 0xfc, 0x45, 0xe3, 0x95, + 0x92, 0x28, 0x44, 0x70, 0xb9, 0x32, 0x76, 0xc7, 0xe8, 0x22, 0x5e, 0xc7, 0xe5, 0xef, 0xb6, 0x90, + 0xc5, 0xf0, 0x82, 0x58, 0xc4, 0x6a, 0x70, 0xf4, 0x36, 0xec, 0x8b, 0x62, 0x11, 0xab, 0x41, 0xd1, + 0xbb, 0x55, 0x78, 0xdb, 0xf1, 0x4a, 0xc3, 0x66, 0x5c, 0x82, 0x7b, 0xc9, 0x62, 0xac, 0x9f, 0x13, + 0xc0, 0x05, 0x99, 0x62, 0x8b, 0x71, 0x2c, 0x6f, 0x2c, 0x24, 0xc8, 0xf2, 0x7a, 0xe9, 0x62, 0xbc, + 0x12, 0x0f, 0x01, 0xcb, 0x9c, 0xb1, 0xc5, 0x38, 0x03, 0x24, 0x8f, 0x97, 0x11, 0x3a, 0x4b, 0xee, + 0xa6, 0x73, 0xa9, 0xe1, 0xa9, 0xe7, 0x75, 0x79, 0xff, 0x8f, 0x2f, 0xc6, 0xf9, 0x53, 0x71, 0x2d, + 0xd8, 0xcb, 0x17, 0xa7, 0xd6, 0xac, 0x83, 0x59, 0x4c, 0x06, 0xc0, 0x1b, 0xeb, 0xc0, 0xf4, 0x67, + 0xf1, 0x0b, 0xd5, 0xc2, 0xa8, 0x0d, 0x17, 0xdb, 0x05, 0x8f, 0x64, 0xc2, 0x4f, 0xfe, 0x5b, 0x2f, + 0x00, 0xf1, 0x7d, 0xf1, 0x9f, 0xfe, 0xb7, 0xa9, 0x77, 0x0d, 0x5a, 0xfb, 0xe9, 0x1b, 0xe1, 0x32, + 0xdd, 0x09, 0xbf, 0x91, 0xc8, 0x0b, 0x52, 0xab, 0xd9, 0xd5, 0x62, 0x26, 0x6b, 0x17, 0x8a, 0x85, + 0x2c, 0xbb, 0x06, 0xbf, 0xa8, 0x68, 0x96, 0xa7, 0x4a, 0xfc, 0x3b, 0x8b, 0x66, 0x69, 0x7a, 0x95, + 0xf5, 0x47, 0x4b, 0xcb, 0x19, 0xfe, 0xdd, 0x53, 0xb3, 0xb4, 0x92, 0x61, 0x83, 0x31, 0xfd, 0x96, + 0xd9, 0x10, 0x7e, 0x91, 0xd1, 0x2c, 0xcd, 0x15, 0xaa, 0xe5, 0x22, 0x1b, 0x8e, 0x82, 0x9f, 0x3e, + 0xc7, 0xf6, 0x80, 0xc2, 0x19, 0x0f, 0x0d, 0x98, 0x3d, 0x9b, 0x2d, 0x57, 0x68, 0x3a, 0x23, 0xd1, + 0x25, 0x3d, 0xb4, 0x9a, 0xaa, 0xb0, 0xbd, 0xf8, 0x65, 0x55, 0xb3, 0xbc, 0xba, 0x56, 0x2d, 0x96, + 0x73, 0xa9, 0x3c, 0xb3, 0xa2, 0xe3, 0xac, 0x16, 0xd9, 0x68, 0xb4, 0x34, 0x5f, 0x62, 0xfb, 0xa2, + 0x93, 0x2d, 0x15, 0x8b, 0xf9, 0x13, 0x6c, 0x7f, 0x14, 0x7c, 0xf9, 0x34, 0x1b, 0xc3, 0xef, 0x75, + 0x86, 0x70, 0xb6, 0x56, 0xa9, 0x16, 0x57, 0xd9, 0x81, 0x18, 0x6c, 0x66, 0x18, 0x8b, 0x96, 0x2e, + 0x65, 0xd8, 0x41, 0xd8, 0xda, 0xeb, 0x43, 0x78, 0x5b, 0xca, 0xe5, 0x73, 0xd5, 0xf3, 0x76, 0xa6, + 0x9c, 0x5a, 0xae, 0xb2, 0x44, 0x74, 0x56, 0x80, 0x92, 0x42, 0x95, 0x5d, 0x1b, 0x45, 0x47, 0xaa, + 0x9c, 0x59, 0x65, 0x87, 0xa2, 0xf3, 0x3a, 0x71, 0xf6, 0xc4, 0x6a, 0x2e, 0xc3, 0x0e, 0xd3, 0x47, + 0x60, 0xcc, 0x16, 0xf9, 0xbc, 0x18, 0xe7, 0xc8, 0xd4, 0x9f, 0x0e, 0x58, 0x63, 0x8a, 0x84, 0x28, + 0x6f, 0x18, 0x34, 0xd5, 0x51, 0x05, 0x5f, 0x5e, 0xcb, 0x67, 0x2b, 0x76, 0xa5, 0x9a, 0xaa, 0xe2, + 0x26, 0xe6, 0xaa, 0x40, 0x4a, 0x27, 0xac, 0x7b, 0x63, 0xab, 0xcf, 0xa5, 0x72, 0x55, 0x7b, 0xb9, + 0x58, 0xb6, 0x4b, 0xf9, 0xd4, 0x79, 0xd8, 0x3e, 0xbb, 0x5a, 0xb4, 0xf3, 0xc5, 0x54, 0x06, 0xe8, + 0xec, 0x0e, 0xeb, 0xd6, 0xd8, 0x26, 0xa7, 0xb3, 0xe5, 0xa2, 0x5d, 0xc9, 0xe6, 0xb3, 0xe9, 0x6a, + 0xae, 0x58, 0x00, 0xd2, 0xbb, 0xdd, 0x9a, 0x8c, 0x05, 0xac, 0x54, 0xcb, 0xf0, 0xcf, 0xca, 0x79, + 0xbb, 0x9a, 0x5b, 0xcd, 0x02, 0x31, 0xde, 0x62, 0xdd, 0x18, 0x0b, 0x57, 0x2a, 0x67, 0xa9, 0x0c, + 0x28, 0xf3, 0x2e, 0xeb, 0x09, 0xb1, 0x20, 0xf8, 0x1b, 0x96, 0x02, 0xa0, 0xc5, 0x95, 0x72, 0xb6, + 0x52, 0x01, 0x72, 0x9d, 0xb4, 0x8e, 0xc5, 0xf7, 0x56, 0xac, 0x54, 0x79, 0x77, 0xc3, 0x20, 0xb3, + 0x6f, 0x8a, 0x85, 0xc9, 0xe4, 0x2a, 0xe9, 0x62, 0xa1, 0x00, 0x2b, 0x00, 0x42, 0xee, 0x35, 0xfd, + 0x6a, 0x36, 0xb5, 0x6a, 0x57, 0x4e, 0x17, 0xcf, 0xa5, 0x53, 0x95, 0x2c, 0x90, 0xf4, 0x94, 0x75, + 0x7b, 0x2c, 0x1c, 0x27, 0x25, 0x3e, 0xc5, 0x4a, 0xb6, 0xba, 0x56, 0x02, 0x32, 0xef, 0xb5, 0x1b, + 0xf9, 0x54, 0xa5, 0xca, 0xac, 0xa9, 0xb7, 0xf7, 0x59, 0xfb, 0x78, 0x7d, 0x9a, 0x86, 0x09, 0xd8, + 0x82, 0xff, 0xb6, 0x57, 0x8a, 0xc5, 0x8c, 0xbd, 0xb2, 0x76, 0xbe, 0x02, 0x5b, 0x77, 0xd4, 0x3a, + 0x6c, 0xd4, 0x2d, 0xa5, 0x44, 0x55, 0x5f, 0xc0, 0x83, 0xb2, 0xaa, 0x0c, 0x5b, 0x07, 0xd3, 0xad, + 0x66, 0xcb, 0xb0, 0x2f, 0xe1, 0x4e, 0x2b, 0x25, 0x58, 0x70, 0x0a, 0xd8, 0x0d, 0xf6, 0x22, 0xdc, + 0x92, 0x6f, 0x3f, 0x71, 0x11, 0xff, 0x30, 0xb2, 0x51, 0x5b, 0x28, 0xe2, 0x3f, 0x6c, 0x68, 0xaa, + 0x28, 0xe6, 0x9d, 0x86, 0x16, 0xb9, 0xf4, 0x19, 0xfc, 0x7c, 0x91, 0xfc, 0x5d, 0x4e, 0x15, 0x32, + 0xc0, 0x51, 0xd7, 0xe0, 0x47, 0x99, 0x65, 0x59, 0xb0, 0x8c, 0x40, 0x6c, 0xa5, 0xb5, 0x15, 0xf4, + 0x4f, 0xbd, 0xac, 0x9f, 0xaf, 0xce, 0xcc, 0xf6, 0x72, 0xed, 0x8e, 0xa2, 0x16, 0xb1, 0x51, 0x40, + 0x6a, 0x02, 0x87, 0x6b, 0x85, 0x33, 0x85, 0xe2, 0xb9, 0x02, 0x8c, 0x74, 0xb7, 0x75, 0x47, 0x3c, + 0x08, 0xcc, 0xd7, 0x3e, 0x9f, 0xad, 0xca, 0x8a, 0x2c, 0x92, 0xb3, 0xa4, 0x85, 0x08, 0x70, 0x00, + 0x14, 0x90, 0x72, 0x04, 0x28, 0xa0, 0x98, 0x2c, 0xca, 0xd5, 0x9e, 0x9d, 0xa5, 0x96, 0x10, 0x0d, + 0x85, 0x2c, 0x8a, 0xd9, 0x9e, 0x2b, 0x40, 0x06, 0xcb, 0x15, 0x56, 0x80, 0x88, 0x6f, 0xb6, 0x6e, + 0x88, 0x07, 0x59, 0x4e, 0xe5, 0xf2, 0xd0, 0xc9, 0xf0, 0xd4, 0x6b, 0xfa, 0xb9, 0xe8, 0xe0, 0x37, + 0x23, 0xc4, 0xf1, 0x78, 0x47, 0x61, 0x33, 0x9f, 0x4d, 0x81, 0xd4, 0x95, 0x0a, 0x43, 0xee, 0xaa, + 0x28, 0x35, 0x26, 0xdd, 0x07, 0x26, 0xd3, 0x2d, 0xbd, 0x6a, 0x81, 0xed, 0x91, 0xef, 0x61, 0x4e, + 0xfd, 0x8a, 0xde, 0x04, 0x58, 0xb0, 0xa2, 0x01, 0xfc, 0x84, 0x95, 0x51, 0xb5, 0x7c, 0x06, 0x96, + 0x29, 0xa5, 0xa2, 0x9c, 0x0a, 0xaa, 0x01, 0x0d, 0xa9, 0x43, 0x60, 0x29, 0xdc, 0xb6, 0x0b, 0x40, + 0x30, 0xf4, 0xb0, 0xe2, 0x69, 0x01, 0xc9, 0x91, 0x80, 0x22, 0xa9, 0x9c, 0x4d, 0x65, 0xce, 0xdb, + 0xc0, 0x5a, 0x7b, 0x94, 0xc8, 0x94, 0xab, 0xc8, 0xa6, 0xf3, 0x39, 0x9c, 0xdd, 0xc8, 0xd4, 0xb3, + 0xfa, 0x38, 0xc1, 0xe7, 0xbd, 0xcb, 0x60, 0x32, 0xe0, 0x6b, 0xc8, 0x3b, 0x4b, 0x4e, 0xab, 0xba, + 0xb3, 0xed, 0xaa, 0xad, 0xc8, 0x17, 0xcf, 0x81, 0x0c, 0xc9, 0x81, 0xc6, 0x01, 0xa9, 0x0d, 0x0b, + 0x93, 0xab, 0x03, 0xdc, 0xf5, 0x04, 0x29, 0x67, 0x4b, 0xc5, 0x72, 0x15, 0x49, 0x58, 0xd2, 0x5b, + 0x04, 0xa4, 0x92, 0x85, 0xe5, 0x64, 0x52, 0xe5, 0xf3, 0xaa, 0xbf, 0xfe, 0xa9, 0xff, 0x8b, 0xf3, + 0x90, 0x48, 0x15, 0x76, 0xea, 0x3b, 0x5c, 0x4e, 0x8b, 0x25, 0x86, 0x8a, 0x81, 0xa8, 0x71, 0x21, + 0xa9, 0x32, 0x2c, 0xe4, 0x1a, 0x49, 0x15, 0x61, 0x98, 0x54, 0x3a, 0x9d, 0x2d, 0xf1, 0xad, 0xec, + 0x01, 0xa1, 0x90, 0xd1, 0x3f, 0x95, 0xe1, 0x5b, 0x85, 0x0a, 0x42, 0x7e, 0x7d, 0x07, 0x30, 0x47, + 0x42, 0x0a, 0xd5, 0x34, 0x52, 0x5a, 0x7a, 0xad, 0x5c, 0x46, 0xf5, 0x74, 0x0d, 0xf2, 0xbb, 0x51, + 0x03, 0x34, 0xb8, 0x94, 0xcf, 0xb2, 0xbe, 0xa9, 0xb7, 0x0d, 0xf0, 0x55, 0xd0, 0xdd, 0x7e, 0x91, + 0xf4, 0x8c, 0x5f, 0x85, 0x96, 0x84, 0xf6, 0xa4, 0x62, 0x0e, 0x11, 0x54, 0x59, 0xcb, 0x57, 0xed, + 0xca, 0x1a, 0xcc, 0xaf, 0x82, 0x12, 0xeb, 0x36, 0xeb, 0xe6, 0x48, 0x6d, 0x2a, 0xcf, 0xf7, 0x10, + 0x4a, 0x48, 0x38, 0xf7, 0xa9, 0xcd, 0xd6, 0xa1, 0x72, 0x85, 0xb3, 0xa9, 0x7c, 0x2e, 0x03, 0x18, + 0x5e, 0x5a, 0x3a, 0x0f, 0xb4, 0x28, 0x75, 0x90, 0x09, 0x93, 0x2e, 0xc2, 0xc4, 0xd3, 0x55, 0xbb, + 0x94, 0xaa, 0x54, 0xce, 0x15, 0xc9, 0xd0, 0x89, 0xeb, 0x2c, 0x45, 0xf3, 0x01, 0xa4, 0x14, 0x72, + 0xc4, 0x8f, 0x71, 0x30, 0x2b, 0xd9, 0x42, 0xb6, 0x9c, 0x4b, 0xdb, 0xd9, 0x72, 0xb9, 0x88, 0x46, + 0x90, 0x14, 0x00, 0xf1, 0x03, 0x0a, 0xfc, 0x68, 0x94, 0x6a, 0xc2, 0x09, 0x59, 0x9a, 0x2a, 0x57, + 0xcf, 0x03, 0xa5, 0x4a, 0x21, 0xa1, 0xc3, 0x14, 0x8a, 0x7c, 0x6d, 0xa0, 0x73, 0x61, 0xcb, 0x41, + 0xab, 0x48, 0xee, 0xd1, 0x81, 0x04, 0xc4, 0x5a, 0x3e, 0x0f, 0xaa, 0xe4, 0xa4, 0x35, 0x1d, 0x01, + 0xd0, 0x55, 0x4e, 0x74, 0x76, 0xd6, 0xd4, 0x7f, 0xb5, 0x0e, 0xab, 0x64, 0x5b, 0xc9, 0x0a, 0xc4, + 0x07, 0xfb, 0xad, 0xbd, 0x48, 0x69, 0xcb, 0x44, 0x24, 0xf4, 0x91, 0xb8, 0x32, 0x88, 0xa2, 0x14, + 0x10, 0x41, 0x5f, 0x62, 0xc4, 0x1a, 0xcc, 0xe4, 0xca, 0x59, 0xc0, 0xfa, 0x98, 0x65, 0x2d, 0xe7, + 0xca, 0xa0, 0x46, 0x51, 0xc6, 0x03, 0x72, 0x0f, 0x58, 0xa3, 0x9c, 0xc2, 0x79, 0xc1, 0xe0, 0xd4, + 0x05, 0x6e, 0xc1, 0xaa, 0x87, 0xa4, 0xa5, 0xcc, 0x50, 0x05, 0x72, 0x23, 0x61, 0x0c, 0xa1, 0x85, + 0x82, 0x2a, 0x50, 0xd0, 0xb9, 0x6a, 0xee, 0x2c, 0x92, 0x40, 0xa4, 0xae, 0x90, 0x5d, 0x49, 0x51, + 0x5d, 0xff, 0xd4, 0xa3, 0xfd, 0xc2, 0x02, 0x22, 0xba, 0xe3, 0x71, 0xaa, 0x87, 0x4a, 0x4b, 0xf8, + 0x85, 0x7c, 0x85, 0xd9, 0x68, 0x15, 0xec, 0xf6, 0x72, 0x0a, 0x50, 0x04, 0x03, 0x4b, 0x7d, 0x1d, + 0x03, 0xb4, 0x94, 0xaa, 0x56, 0xf3, 0x60, 0xd4, 0x15, 0x8b, 0xa4, 0x2a, 0x03, 0x5b, 0x27, 0x06, + 0xb6, 0x72, 0x1a, 0xb8, 0x12, 0x40, 0x0b, 0x6b, 0xa0, 0xaf, 0x02, 0x29, 0x11, 0x05, 0xe4, 0xdb, + 0x3e, 0xb0, 0x5b, 0x5f, 0xb0, 0x4d, 0xe5, 0xb5, 0x5c, 0x75, 0x15, 0xb9, 0x2e, 0xa0, 0xc7, 0xb8, + 0xbe, 0xd2, 0x20, 0x47, 0x40, 0x41, 0x4c, 0x3d, 0xac, 0x49, 0x91, 0xb3, 0x0d, 0xbf, 0xc1, 0x3f, + 0xb5, 0x9a, 0x38, 0x66, 0x4d, 0xc4, 0x14, 0xdb, 0xa5, 0xee, 0x85, 0x66, 0xa3, 0x06, 0x6b, 0x17, + 0x54, 0x15, 0xae, 0x17, 0xa7, 0x01, 0x21, 0x01, 0xa2, 0x01, 0xac, 0xb5, 0xf0, 0x83, 0xb1, 0xe0, + 0xa7, 0x10, 0xfe, 0x13, 0xf4, 0x25, 0x2b, 0x71, 0x7b, 0x73, 0xb5, 0x4c, 0x14, 0x74, 0x33, 0x05, + 0xbf, 0x22, 0xe5, 0xf8, 0x9a, 0x3f, 0x66, 0x88, 0xc0, 0xd8, 0xb7, 0x93, 0xa7, 0x19, 0x85, 0x10, + 0x5f, 0xba, 0x3a, 0xdd, 0xa8, 0xd7, 0xdd, 0x16, 0x57, 0xc8, 0xb1, 0x70, 0x15, 0xaf, 0xe9, 0x09, + 0xa0, 0x7e, 0x14, 0xb9, 0xbb, 0x75, 0x46, 0x07, 0xdd, 0x9d, 0x46, 0xa7, 0x71, 0x09, 0xbf, 0x66, + 0x78, 0x27, 0xf9, 0x76, 0xf1, 0x3d, 0xea, 0x90, 0x83, 0xb8, 0x47, 0xb1, 0x90, 0x27, 0x2e, 0x9d, + 0xd0, 0x01, 0x87, 0xa6, 0xbe, 0xd0, 0x67, 0xed, 0xe5, 0x87, 0xfa, 0xb8, 0x78, 0x30, 0x6d, 0x56, + 0x53, 0xd5, 0xf4, 0x69, 0xbb, 0x7a, 0xbe, 0x04, 0x86, 0x43, 0xaa, 0xb2, 0x06, 0x8e, 0xcb, 0x35, + 0x28, 0x58, 0xf5, 0xe2, 0x62, 0xb1, 0x04, 0xf4, 0x42, 0x1a, 0x03, 0x08, 0x5c, 0xab, 0x21, 0xe9, + 0x00, 0x76, 0xd2, 0x19, 0xb2, 0x35, 0x00, 0x93, 0x5a, 0x5d, 0x1e, 0x28, 0x3f, 0x7d, 0xde, 0xae, + 0x14, 0xf3, 0x45, 0xfb, 0xc1, 0xb5, 0xec, 0x1a, 0x1a, 0xcc, 0x66, 0xeb, 0x74, 0x71, 0xb5, 0x94, + 0xad, 0x72, 0xd6, 0x19, 0x44, 0x0a, 0xd0, 0xea, 0xce, 0x65, 0xb3, 0x67, 0xb2, 0x05, 0x54, 0x95, + 0x6b, 0xe5, 0x42, 0xf6, 0x3c, 0xc3, 0x4f, 0x15, 0x1f, 0x8e, 0x4c, 0x15, 0xbd, 0x0b, 0xee, 0xcf, + 0x69, 0x55, 0xdc, 0x45, 0xd9, 0x33, 0xf5, 0xb4, 0x7e, 0x6e, 0xb7, 0x2d, 0x79, 0x9d, 0x4c, 0x63, + 0x7d, 0xbd, 0x51, 0x03, 0x39, 0xbf, 0x83, 0x53, 0x80, 0xa5, 0x80, 0xad, 0xb0, 0xbc, 0x9c, 0x4b, + 0x03, 0x5f, 0x9d, 0x27, 0xa1, 0x8b, 0x53, 0x20, 0xad, 0x11, 0xaa, 0xcb, 0xa6, 0x2a, 0xe7, 0x61, + 0xd5, 0x30, 0x76, 0xa8, 0x62, 0x35, 0x9b, 0xc9, 0xad, 0xa1, 0x9b, 0x1a, 0x6d, 0x03, 0xec, 0x85, + 0x02, 0x3c, 0xda, 0x66, 0xad, 0x00, 0xfa, 0xbf, 0x0c, 0x4b, 0x8d, 0xce, 0x41, 0x4a, 0x97, 0xa1, + 0x98, 0x66, 0xd9, 0x87, 0xc0, 0xed, 0xc0, 0x65, 0xf6, 0xa8, 0x3a, 0x09, 0x92, 0xb9, 0x47, 0xd5, + 0xfd, 0x60, 0x44, 0x7c, 0xab, 0xcf, 0x1a, 0xe3, 0x29, 0x6b, 0x4e, 0x6b, 0xa3, 0x8b, 0xd7, 0x1c, + 0x83, 0x6d, 0xc8, 0x03, 0x4f, 0xae, 0xa5, 0x56, 0xb2, 0xa6, 0x74, 0x0b, 0xd5, 0x65, 0x0b, 0x2b, + 0xf9, 0x5c, 0xe5, 0xb4, 0xbe, 0xf9, 0xaa, 0xae, 0xbc, 0x06, 0xb8, 0x4b, 0x15, 0xb8, 0x6d, 0x1e, + 0xaa, 0x4b, 0x9f, 0x06, 0xa1, 0x5c, 0xc9, 0x72, 0x54, 0x84, 0xea, 0xce, 0x14, 0x41, 0x79, 0x16, + 0x38, 0x2a, 0x42, 0x55, 0x95, 0x52, 0xaa, 0x80, 0xc3, 0x0d, 0xa1, 0xcf, 0x11, 0xaa, 0x43, 0xbb, + 0x65, 0x6d, 0x65, 0x0d, 0x7b, 0x1d, 0x46, 0x87, 0x32, 0x7e, 0xa6, 0x80, 0x10, 0x10, 0xe8, 0xd7, + 0x66, 0x83, 0x2c, 0xe5, 0xaa, 0xbb, 0xb5, 0xdd, 0x44, 0x63, 0xe5, 0x18, 0xc5, 0x32, 0xa2, 0x15, + 0x76, 0xc1, 0xa3, 0x8f, 0x8c, 0x72, 0xee, 0x8c, 0xa9, 0xaf, 0xd0, 0x77, 0x65, 0xb3, 0xcd, 0x06, + 0x3d, 0x3a, 0x82, 0x11, 0xc0, 0xbe, 0xa9, 0xb3, 0xd6, 0x01, 0x1d, 0x14, 0xf9, 0xe9, 0x46, 0x3a, + 0x66, 0x36, 0x0b, 0x41, 0x06, 0x5d, 0x6c, 0x79, 0x97, 0x5b, 0xdc, 0x8e, 0x88, 0x56, 0x63, 0x9e, + 0x7d, 0x73, 0x27, 0xd3, 0xb8, 0xd4, 0xf0, 0x79, 0xbf, 0x2f, 0x1c, 0xb0, 0x86, 0xb3, 0x74, 0x62, + 0x9f, 0x38, 0x68, 0xed, 0x27, 0x72, 0xb6, 0xc1, 0x84, 0x10, 0x26, 0x31, 0xb0, 0xac, 0x2a, 0x42, + 0xf5, 0x56, 0xcd, 0x65, 0xb2, 0xdc, 0x73, 0x52, 0xc5, 0x15, 0xb0, 0xe5, 0x0a, 0x2b, 0xf6, 0x72, + 0xb6, 0x02, 0xbc, 0x05, 0x0c, 0xdd, 0x8f, 0xb8, 0x52, 0xb5, 0xcb, 0xe5, 0x22, 0x96, 0xaf, 0x55, + 0xec, 0x93, 0xc7, 0x4f, 0xdc, 0xcf, 0x5d, 0x27, 0x55, 0x49, 0x3c, 0x59, 0x40, 0xda, 0xc6, 0xda, + 0x07, 0xf8, 0x0e, 0x05, 0x53, 0xc8, 0x3e, 0x04, 0xc6, 0x54, 0x29, 0x6d, 0x73, 0x61, 0x6e, 0xd4, + 0x95, 0xce, 0x95, 0x61, 0x42, 0xa9, 0x34, 0xb6, 0x7b, 0x22, 0xdf, 0x1e, 0xad, 0xdd, 0x39, 0x7b, + 0x29, 0x5f, 0x2c, 0xae, 0xf2, 0xca, 0x3d, 0x28, 0xce, 0x55, 0x65, 0xae, 0x00, 0x2a, 0xab, 0x90, + 0x42, 0x5f, 0x01, 0x38, 0x9a, 0x00, 0x46, 0x8c, 0x39, 0x2d, 0x63, 0xa4, 0x60, 0x35, 0xf5, 0x24, + 0x70, 0xea, 0xa9, 0x76, 0x2f, 0x46, 0x1f, 0x54, 0x6d, 0xb1, 0x9c, 0x4a, 0x83, 0xea, 0x2b, 0xa5, + 0x98, 0x85, 0xf8, 0xed, 0x31, 0x26, 0xfa, 0xe4, 0x4b, 0x59, 0x74, 0x56, 0x47, 0x8d, 0xd6, 0x0a, + 0x19, 0x6c, 0x1f, 0x12, 0x87, 0x2a, 0x3f, 0x47, 0xb3, 0xd2, 0x47, 0xdd, 0x3f, 0x55, 0xb2, 0x18, + 0xa9, 0x97, 0x8c, 0xd7, 0x71, 0xaa, 0x67, 0xe9, 0x1a, 0x0e, 0xfa, 0x8b, 0x5a, 0x99, 0x7d, 0xe2, + 0x38, 0xec, 0x10, 0x38, 0x15, 0x46, 0xd9, 0xc9, 0xe3, 0xb0, 0x3f, 0xa1, 0xc2, 0xfb, 0x8f, 0x1f, + 0x47, 0x95, 0xd4, 0x67, 0x1d, 0x56, 0xa5, 0x25, 0xa7, 0xeb, 0xbb, 0x15, 0xb7, 0xd3, 0x01, 0x52, + 0x43, 0x5d, 0x12, 0x5b, 0x41, 0x0a, 0x6d, 0xab, 0xd1, 0xa1, 0x6f, 0xed, 0x82, 0xee, 0x8e, 0x07, + 0xca, 0x0b, 0x10, 0xb2, 0x49, 0xe3, 0x41, 0x32, 0x0d, 0x9f, 0x1f, 0x0a, 0xf4, 0x4f, 0x3d, 0xde, + 0x0f, 0x54, 0x46, 0x22, 0x42, 0x64, 0xf2, 0xe3, 0xde, 0x61, 0x4c, 0x51, 0x2b, 0xd2, 0x88, 0x98, + 0xf3, 0x90, 0x51, 0x59, 0x76, 0xea, 0x22, 0x85, 0x1b, 0x68, 0xed, 0x26, 0x1e, 0x32, 0xd6, 0xeb, + 0xf1, 0xbb, 0x04, 0x12, 0x60, 0x20, 0x71, 0x3f, 0x3f, 0xd5, 0xd7, 0x01, 0x0a, 0x5e, 0x87, 0x6e, + 0x07, 0xd5, 0xed, 0x92, 0xe7, 0xb5, 0x0b, 0x6e, 0xe7, 0xb2, 0xd7, 0xbe, 0x08, 0x2e, 0x34, 0x4f, + 0x27, 0xf3, 0xd9, 0xcf, 0x0b, 0xd6, 0xe9, 0xd1, 0x48, 0xdc, 0xb2, 0x4f, 0x61, 0xb8, 0xa5, 0x37, + 0x54, 0x25, 0x48, 0x4d, 0x64, 0x4b, 0x68, 0x4d, 0xf5, 0x06, 0x2d, 0xb8, 0xc1, 0x69, 0x1d, 0x4b, + 0x4f, 0x3d, 0x36, 0x24, 0x4c, 0x07, 0x3c, 0x05, 0xa7, 0x54, 0xb0, 0x82, 0xeb, 0xd6, 0x35, 0xd3, + 0xc1, 0x28, 0xd7, 0x70, 0x75, 0x0f, 0x45, 0xeb, 0x63, 0x20, 0x7c, 0xb7, 0x5d, 0xf0, 0xb4, 0x12, + 0x18, 0xa6, 0x2e, 0x66, 0x1f, 0x0f, 0x9d, 0x6b, 0x15, 0x5b, 0xf8, 0x04, 0x08, 0x7d, 0x31, 0xc4, + 0xd5, 0x2c, 0x83, 0x38, 0x50, 0x7c, 0xf7, 0xbd, 0x49, 0x90, 0xeb, 0x89, 0x7b, 0xe9, 0xfc, 0xa3, + 0x17, 0xe4, 0x5a, 0xee, 0x9c, 0xe3, 0xab, 0x8f, 0x44, 0xb2, 0x8d, 0xc4, 0x7d, 0x14, 0x80, 0xee, + 0x0d, 0x4e, 0x98, 0x09, 0x1a, 0x6c, 0x6a, 0xd6, 0x51, 0xb4, 0x81, 0x7c, 0x1f, 0xd5, 0x67, 0x0d, + 0x0c, 0xd8, 0x5d, 0xf5, 0x3c, 0x72, 0xf5, 0xa6, 0xcb, 0x7e, 0x51, 0x10, 0xca, 0xd5, 0xce, 0x85, + 0x1a, 0x5d, 0x14, 0x67, 0x77, 0xd1, 0x46, 0xc1, 0x67, 0x55, 0x38, 0x22, 0xd9, 0x7b, 0xfa, 0x44, + 0xec, 0x7c, 0x37, 0x58, 0xc2, 0x24, 0x7b, 0x6f, 0x9f, 0x38, 0x1d, 0xd8, 0x0d, 0x94, 0xc6, 0xff, + 0xdb, 0xab, 0xe9, 0x94, 0x92, 0xf2, 0xd9, 0xfb, 0xfa, 0xc4, 0x89, 0xee, 0x15, 0xc7, 0xe7, 0x1f, + 0x9f, 0x61, 0x7f, 0xd7, 0x37, 0xf5, 0x7f, 0x5a, 0xfb, 0x45, 0x22, 0xba, 0x8d, 0x6f, 0xc0, 0x93, + 0x2a, 0x5f, 0x06, 0x6f, 0x07, 0xcc, 0x14, 0xbb, 0x5c, 0xcc, 0x67, 0x6d, 0xdd, 0x19, 0x02, 0x4d, + 0x61, 0xd4, 0x81, 0x5b, 0x85, 0x9a, 0x02, 0x8c, 0x3b, 0xa3, 0xb8, 0xb2, 0x56, 0x42, 0xbd, 0x0a, + 0x82, 0xe0, 0x99, 0x7d, 0x56, 0x42, 0x76, 0x8f, 0xc7, 0xf0, 0x36, 0x5d, 0xee, 0xd0, 0xfb, 0xa9, + 0xe4, 0x8b, 0x55, 0x4d, 0x11, 0x19, 0xc5, 0xd1, 0xee, 0xa9, 0x58, 0x75, 0x8f, 0x66, 0x9a, 0x51, + 0x93, 0x2a, 0xa0, 0x77, 0x01, 0xd2, 0xd8, 0x28, 0x5d, 0xca, 0x16, 0xd2, 0xa7, 0xc1, 0x25, 0x7b, + 0x67, 0x3f, 0x2c, 0x4d, 0x4c, 0x46, 0xf9, 0x7e, 0x36, 0x1d, 0x2f, 0x80, 0x96, 0x55, 0x4d, 0x64, + 0xd8, 0x56, 0x33, 0x61, 0x40, 0x77, 0x44, 0xab, 0xf3, 0xc5, 0xf4, 0x19, 0x8a, 0x34, 0xc4, 0x36, + 0xae, 0x9c, 0x5e, 0x5b, 0x5e, 0xce, 0x67, 0xb9, 0xf4, 0x8a, 0x56, 0x2f, 0x97, 0xb3, 0x59, 0xe9, + 0x3b, 0x82, 0x6c, 0x8c, 0x02, 0x80, 0xca, 0x24, 0x8f, 0x1c, 0x24, 0x42, 0xb4, 0x12, 0xc3, 0xc1, + 0x15, 0xd0, 0x3d, 0xe0, 0xc9, 0x0e, 0xc5, 0xf7, 0x8f, 0x10, 0x3c, 0x14, 0x3e, 0x8c, 0xe2, 0x35, + 0x0a, 0x40, 0x95, 0x18, 0x61, 0xdb, 0x83, 0x82, 0x30, 0x5a, 0x5f, 0xce, 0xae, 0xac, 0xe5, 0x53, + 0x65, 0x39, 0xcc, 0xc8, 0xd4, 0x77, 0xfb, 0x44, 0xd0, 0x2b, 0x30, 0x36, 0xc8, 0xa2, 0xf0, 0x51, + 0x63, 0x61, 0x38, 0x8e, 0xdc, 0x61, 0xd4, 0x8f, 0x88, 0x31, 0xf0, 0x87, 0x65, 0x4c, 0x1a, 0x56, + 0x02, 0x48, 0x02, 0xbb, 0x03, 0x0a, 0x56, 0xc1, 0x92, 0xcc, 0xd9, 0x67, 0x72, 0x79, 0x34, 0x21, + 0x98, 0xb5, 0x4f, 0xc6, 0xca, 0x33, 0x59, 0xda, 0x39, 0x0e, 0x94, 0xca, 0xae, 0xe4, 0x2a, 0xbc, + 0x68, 0x10, 0xb5, 0x9c, 0x2a, 0x02, 0x8f, 0x3e, 0x9f, 0xc5, 0x25, 0x83, 0xf7, 0x8d, 0xbd, 0x17, + 0x33, 0xf9, 0xdc, 0x19, 0x34, 0xdc, 0x38, 0x50, 0x1a, 0x2c, 0xfb, 0x1c, 0xa8, 0x58, 0xea, 0x7e, + 0x8f, 0x98, 0x42, 0x36, 0x7d, 0xba, 0x58, 0xc9, 0xa7, 0xf0, 0xc0, 0x05, 0x3c, 0x7b, 0x28, 0x28, + 0xa7, 0x4a, 0x00, 0x04, 0x2a, 0x9f, 0x37, 0xca, 0xa6, 0xca, 0x79, 0x24, 0x5b, 0xf0, 0x61, 0x0b, + 0xa0, 0xef, 0xf9, 0x0c, 0x96, 0xf2, 0xa9, 0xf4, 0x19, 0xfb, 0x34, 0x8c, 0xc6, 0x46, 0xa7, 0xde, + 0x35, 0x2c, 0xc2, 0x69, 0x60, 0xc9, 0x80, 0x57, 0x9c, 0x2f, 0xae, 0x90, 0x57, 0x50, 0x51, 0x51, + 0xc0, 0xa0, 0x3c, 0x93, 0x5a, 0x05, 0xab, 0x91, 0xdb, 0xfd, 0xa1, 0xaa, 0xd3, 0x59, 0x30, 0x9b, + 0xfa, 0x54, 0x2c, 0x23, 0xa8, 0x58, 0x2d, 0x82, 0x8d, 0x8d, 0xd3, 0x4e, 0x65, 0xd0, 0xe5, 0x91, + 0x1e, 0x6f, 0x0c, 0x40, 0x39, 0xbb, 0x5a, 0x3c, 0x8b, 0xd6, 0xef, 0x78, 0x64, 0x42, 0x99, 0x6c, + 0xaa, 0x7a, 0x9a, 0x9b, 0x56, 0xa1, 0x1a, 0x71, 0xfe, 0xa2, 0x1d, 0x5e, 0x05, 0x75, 0xb9, 0x6a, + 0x76, 0x95, 0xdb, 0x55, 0xa1, 0x0a, 0x20, 0x6d, 0xb2, 0x9e, 0x00, 0x8b, 0xd1, 0x56, 0x2b, 0xc5, + 0x3c, 0x46, 0x65, 0x64, 0xfc, 0x5e, 0xab, 0xa0, 0xf0, 0x3e, 0xc6, 0x66, 0x01, 0xbb, 0x2a, 0xc4, + 0xad, 0xaa, 0x1f, 0x2a, 0x01, 0x7e, 0xa3, 0x63, 0x95, 0xd6, 0xca, 0xe9, 0xd3, 0x78, 0x7c, 0x30, + 0x1a, 0x33, 0xfb, 0xa5, 0xb5, 0xf3, 0x4b, 0xb0, 0x15, 0x60, 0x4a, 0x45, 0xf1, 0x22, 0x4f, 0x96, + 0xaa, 0xe5, 0xdc, 0xca, 0x0a, 0xec, 0xe8, 0x7e, 0xe9, 0xf2, 0xeb, 0x9d, 0xf3, 0x23, 0x1b, 0x98, + 0x53, 0x85, 0x8d, 0xa9, 0x90, 0x9c, 0x86, 0x5b, 0xa4, 0x47, 0xa2, 0x97, 0x03, 0x31, 0x0b, 0xc2, + 0x8a, 0x4a, 0x15, 0xfc, 0x8a, 0x33, 0x8c, 0xa9, 0xd0, 0xb0, 0x46, 0x05, 0x74, 0x9e, 0xb0, 0x96, + 0xcb, 0x63, 0xa4, 0x9a, 0x53, 0xdd, 0xc1, 0x98, 0x39, 0xe8, 0x8c, 0x91, 0xd0, 0xc2, 0xe2, 0x31, + 0xfb, 0x0b, 0x52, 0x01, 0xfc, 0x94, 0x6b, 0x63, 0xc6, 0x2a, 0x64, 0xd7, 0xc0, 0xfb, 0xca, 0x83, + 0x97, 0xba, 0x5a, 0x42, 0x1c, 0x03, 0x4e, 0x0e, 0xc5, 0xad, 0x17, 0x24, 0xca, 0x5a, 0x09, 0x9c, + 0x28, 0x90, 0xa7, 0x87, 0x63, 0xba, 0xc1, 0x03, 0xc8, 0x14, 0x06, 0x8c, 0x41, 0xb6, 0xe5, 0x2a, + 0x39, 0x8c, 0x60, 0x1e, 0x89, 0x59, 0x38, 0x3f, 0xbf, 0x4a, 0x9d, 0x05, 0x09, 0x74, 0x9d, 0x16, + 0x80, 0x57, 0x33, 0x4e, 0x15, 0x52, 0x18, 0x67, 0xab, 0x16, 0x31, 0x18, 0x3b, 0x1e, 0x43, 0xd4, + 0xd4, 0x41, 0x1e, 0x06, 0xcb, 0xaf, 0x95, 0xd8, 0xd1, 0xa9, 0x57, 0x0c, 0x8a, 0x23, 0x8c, 0xe0, + 0x01, 0x38, 0x72, 0x54, 0x54, 0x94, 0x54, 0x2f, 0xe4, 0x29, 0x26, 0xa0, 0x23, 0x55, 0x60, 0x4c, + 0xaf, 0xe5, 0x59, 0x4d, 0xdc, 0x83, 0x0e, 0xd7, 0xf1, 0xc4, 0x8f, 0xfe, 0xb8, 0x2a, 0xfe, 0x62, + 0x85, 0x62, 0x1d, 0xbd, 0x8a, 0xd2, 0xc3, 0x06, 0xe3, 0x1a, 0xd1, 0x83, 0xf6, 0xc0, 0x39, 0x82, + 0x68, 0xf5, 0x2a, 0xa1, 0x47, 0x02, 0xee, 0xd1, 0x2b, 0xcf, 0x6d, 0x36, 0xfc, 0x6d, 0xb0, 0x1e, + 0xf7, 0xc4, 0x55, 0x8a, 0x87, 0xa7, 0x80, 0x83, 0x04, 0x6b, 0x19, 0x73, 0x71, 0x2e, 0x00, 0xef, + 0xc4, 0xb4, 0x92, 0xb1, 0x23, 0x2b, 0xae, 0x12, 0x95, 0x7b, 0xaa, 0xd9, 0x04, 0x0e, 0x12, 0x14, + 0x11, 0x53, 0x89, 0xd7, 0x08, 0xf6, 0xc9, 0xd8, 0x5c, 0xb8, 0x5e, 0xdd, 0xe7, 0x07, 0x26, 0x12, + 0xdb, 0x1d, 0x06, 0xa1, 0xe7, 0x5e, 0x31, 0x6d, 0x6c, 0x2c, 0x0e, 0x87, 0x69, 0x67, 0xdd, 0x05, + 0x16, 0x8a, 0x19, 0x3e, 0xc8, 0x42, 0x03, 0x1e, 0x8a, 0x99, 0xbb, 0xc8, 0x5c, 0x60, 0x07, 0x97, + 0x86, 0x4e, 0xf7, 0x3d, 0xd2, 0x77, 0xcd, 0xff, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x7c, 0x0b, 0xbb, + 0xf3, 0x21, 0xca, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/econ.pb.go b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/econ.pb.go new file mode 100644 index 00000000..db3960f2 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/econ.pb.go @@ -0,0 +1,4441 @@ +// Code generated by protoc-gen-go. +// source: econ_gcmessages.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 protobuf is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type EGCItemMsg int32 + +const ( + EGCItemMsg_k_EMsgGCBase EGCItemMsg = 1000 + EGCItemMsg_k_EMsgGCSetItemPosition EGCItemMsg = 1001 + EGCItemMsg_k_EMsgGCCraft EGCItemMsg = 1002 + EGCItemMsg_k_EMsgGCCraftResponse EGCItemMsg = 1003 + EGCItemMsg_k_EMsgGCDelete EGCItemMsg = 1004 + EGCItemMsg_k_EMsgGCVerifyCacheSubscription EGCItemMsg = 1005 + EGCItemMsg_k_EMsgClientToGCNameItem EGCItemMsg = 1006 + EGCItemMsg_k_EMsgGCPaintItem EGCItemMsg = 1009 + EGCItemMsg_k_EMsgGCPaintItemResponse EGCItemMsg = 1010 + EGCItemMsg_k_EMsgGCGoldenWrenchBroadcast EGCItemMsg = 1011 + EGCItemMsg_k_EMsgGCMOTDRequest EGCItemMsg = 1012 + EGCItemMsg_k_EMsgGCMOTDRequestResponse EGCItemMsg = 1013 + EGCItemMsg_k_EMsgGCAddItemToSocket_DEPRECATED EGCItemMsg = 1014 + EGCItemMsg_k_EMsgGCAddItemToSocketResponse_DEPRECATED EGCItemMsg = 1015 + EGCItemMsg_k_EMsgGCAddSocketToBaseItem_DEPRECATED EGCItemMsg = 1016 + EGCItemMsg_k_EMsgGCAddSocketToItem_DEPRECATED EGCItemMsg = 1017 + EGCItemMsg_k_EMsgGCAddSocketToItemResponse_DEPRECATED EGCItemMsg = 1018 + EGCItemMsg_k_EMsgGCNameBaseItem EGCItemMsg = 1019 + EGCItemMsg_k_EMsgGCNameBaseItemResponse EGCItemMsg = 1020 + EGCItemMsg_k_EMsgGCRemoveSocketItem_DEPRECATED EGCItemMsg = 1021 + EGCItemMsg_k_EMsgGCRemoveSocketItemResponse_DEPRECATED EGCItemMsg = 1022 + EGCItemMsg_k_EMsgGCCustomizeItemTexture EGCItemMsg = 1023 + EGCItemMsg_k_EMsgGCCustomizeItemTextureResponse EGCItemMsg = 1024 + EGCItemMsg_k_EMsgGCUseItemRequest EGCItemMsg = 1025 + EGCItemMsg_k_EMsgGCUseItemResponse EGCItemMsg = 1026 + EGCItemMsg_k_EMsgGCGiftedItems EGCItemMsg = 1027 + EGCItemMsg_k_EMsgGCRemoveItemName EGCItemMsg = 1030 + EGCItemMsg_k_EMsgGCRemoveItemPaint EGCItemMsg = 1031 + EGCItemMsg_k_EMsgGCUnwrapGiftRequest EGCItemMsg = 1037 + EGCItemMsg_k_EMsgGCUnwrapGiftResponse EGCItemMsg = 1038 + EGCItemMsg_k_EMsgGCSetItemStyle_DEPRECATED EGCItemMsg = 1039 + EGCItemMsg_k_EMsgGCUsedClaimCodeItem EGCItemMsg = 1040 + EGCItemMsg_k_EMsgGCSortItems EGCItemMsg = 1041 + EGCItemMsg_k_EMsgGC_RevolvingLootList_DEPRECATED EGCItemMsg = 1042 + EGCItemMsg_k_EMsgGCUpdateItemSchema EGCItemMsg = 1049 + EGCItemMsg_k_EMsgGCRemoveCustomTexture EGCItemMsg = 1051 + EGCItemMsg_k_EMsgGCRemoveCustomTextureResponse EGCItemMsg = 1052 + EGCItemMsg_k_EMsgGCRemoveMakersMark EGCItemMsg = 1053 + EGCItemMsg_k_EMsgGCRemoveMakersMarkResponse EGCItemMsg = 1054 + EGCItemMsg_k_EMsgGCRemoveUniqueCraftIndex EGCItemMsg = 1055 + EGCItemMsg_k_EMsgGCRemoveUniqueCraftIndexResponse EGCItemMsg = 1056 + EGCItemMsg_k_EMsgGCSaxxyBroadcast EGCItemMsg = 1057 + EGCItemMsg_k_EMsgGCBackpackSortFinished EGCItemMsg = 1058 + EGCItemMsg_k_EMsgGCAdjustItemEquippedState EGCItemMsg = 1059 + EGCItemMsg_k_EMsgGCCollectItem EGCItemMsg = 1061 + EGCItemMsg_k_EMsgGCItemAcknowledged EGCItemMsg = 1062 + EGCItemMsg_k_EMsgGCPresets_SelectPresetForClass EGCItemMsg = 1063 + EGCItemMsg_k_EMsgGCPresets_SetItemPosition EGCItemMsg = 1064 + EGCItemMsg_k_EMsgGCPresets_SelectPresetForClassReply EGCItemMsg = 1067 + EGCItemMsg_k_EMsgClientToGCNameItemResponse EGCItemMsg = 1068 + EGCItemMsg_k_EMsgGCApplyConsumableEffects EGCItemMsg = 1069 + EGCItemMsg_k_EMsgGCConsumableExhausted EGCItemMsg = 1070 + EGCItemMsg_k_EMsgGCShowItemsPickedUp EGCItemMsg = 1071 + EGCItemMsg_k_EMsgGCClientDisplayNotification EGCItemMsg = 1072 + EGCItemMsg_k_EMsgGCApplyStrangePart EGCItemMsg = 1073 + EGCItemMsg_k_EMsgGC_IncrementKillCountResponse EGCItemMsg = 1075 + EGCItemMsg_k_EMsgGCApplyPennantUpgrade EGCItemMsg = 1076 + EGCItemMsg_k_EMsgGCSetItemPositions EGCItemMsg = 1077 + EGCItemMsg_k_EMsgGCSetItemPositions_RateLimited EGCItemMsg = 1096 + EGCItemMsg_k_EMsgGCApplyEggEssence EGCItemMsg = 1078 + EGCItemMsg_k_EMsgGCNameEggEssenceResponse EGCItemMsg = 1079 + EGCItemMsg_k_EMsgGCFulfillDynamicRecipeComponent EGCItemMsg = 1082 + EGCItemMsg_k_EMsgGCFulfillDynamicRecipeComponentResponse EGCItemMsg = 1083 + EGCItemMsg_k_EMsgGCClientRequestMarketData EGCItemMsg = 1084 + EGCItemMsg_k_EMsgGCClientRequestMarketDataResponse EGCItemMsg = 1085 + EGCItemMsg_k_EMsgGCExtractGems EGCItemMsg = 1086 + EGCItemMsg_k_EMsgGCAddSocket EGCItemMsg = 1087 + EGCItemMsg_k_EMsgGCAddItemToSocket EGCItemMsg = 1088 + EGCItemMsg_k_EMsgGCAddItemToSocketResponse EGCItemMsg = 1089 + EGCItemMsg_k_EMsgGCAddSocketResponse EGCItemMsg = 1090 + EGCItemMsg_k_EMsgGCResetStrangeGemCount EGCItemMsg = 1091 + EGCItemMsg_k_EMsgGCRequestCrateItems EGCItemMsg = 1092 + EGCItemMsg_k_EMsgGCRequestCrateItemsResponse EGCItemMsg = 1093 + EGCItemMsg_k_EMsgGCExtractGemsResponse EGCItemMsg = 1094 + EGCItemMsg_k_EMsgGCResetStrangeGemCountResponse EGCItemMsg = 1095 + EGCItemMsg_k_EMsgGCServerUseItemRequest EGCItemMsg = 1103 + EGCItemMsg_k_EMsgGCAddGiftItem EGCItemMsg = 1104 + EGCItemMsg_k_EMsgGCRemoveItemGiftMessage EGCItemMsg = 1105 + EGCItemMsg_k_EMsgGCRemoveItemGiftMessageResponse EGCItemMsg = 1106 + EGCItemMsg_k_EMsgGCRemoveItemGifterAccountId EGCItemMsg = 1107 + EGCItemMsg_k_EMsgGCRemoveItemGifterAccountIdResponse EGCItemMsg = 1108 + EGCItemMsg_k_EMsgClientToGCRemoveItemGifterAttributes EGCItemMsg = 1109 + EGCItemMsg_k_EMsgClientToGCRemoveItemName EGCItemMsg = 1110 + EGCItemMsg_k_EMsgClientToGCRemoveItemDescription EGCItemMsg = 1111 + EGCItemMsg_k_EMsgClientToGCRemoveItemAttributeResponse EGCItemMsg = 1112 + EGCItemMsg_k_EMsgGCTradingBase EGCItemMsg = 1500 + EGCItemMsg_k_EMsgGCTrading_InitiateTradeRequest EGCItemMsg = 1501 + EGCItemMsg_k_EMsgGCTrading_InitiateTradeResponse EGCItemMsg = 1502 + EGCItemMsg_k_EMsgGCTrading_StartSession EGCItemMsg = 1503 + EGCItemMsg_k_EMsgGCTrading_SessionClosed EGCItemMsg = 1509 + EGCItemMsg_k_EMsgGCTrading_InitiateTradeRequestResponse EGCItemMsg = 1514 + EGCItemMsg_k_EMsgGCServerBrowser_FavoriteServer EGCItemMsg = 1601 + EGCItemMsg_k_EMsgGCServerBrowser_BlacklistServer EGCItemMsg = 1602 + EGCItemMsg_k_EMsgGCServerRentalsBase EGCItemMsg = 1700 + EGCItemMsg_k_EMsgGCItemPreviewCheckStatus EGCItemMsg = 1701 + EGCItemMsg_k_EMsgGCItemPreviewStatusResponse EGCItemMsg = 1702 + EGCItemMsg_k_EMsgGCItemPreviewRequest EGCItemMsg = 1703 + EGCItemMsg_k_EMsgGCItemPreviewRequestResponse EGCItemMsg = 1704 + EGCItemMsg_k_EMsgGCItemPreviewExpire EGCItemMsg = 1705 + EGCItemMsg_k_EMsgGCItemPreviewExpireNotification EGCItemMsg = 1706 + EGCItemMsg_k_EMsgGCItemPreviewItemBoughtNotification EGCItemMsg = 1707 + EGCItemMsg_k_EMsgGCDev_NewItemRequest EGCItemMsg = 2001 + EGCItemMsg_k_EMsgGCDev_NewItemRequestResponse EGCItemMsg = 2002 + EGCItemMsg_k_EMsgGCStoreGetUserData EGCItemMsg = 2500 + EGCItemMsg_k_EMsgGCStoreGetUserDataResponse EGCItemMsg = 2501 + EGCItemMsg_k_EMsgGCStorePurchaseFinalize EGCItemMsg = 2504 + EGCItemMsg_k_EMsgGCStorePurchaseFinalizeResponse EGCItemMsg = 2505 + EGCItemMsg_k_EMsgGCStorePurchaseCancel EGCItemMsg = 2506 + EGCItemMsg_k_EMsgGCStorePurchaseCancelResponse EGCItemMsg = 2507 + EGCItemMsg_k_EMsgGCStorePurchaseInit EGCItemMsg = 2510 + EGCItemMsg_k_EMsgGCStorePurchaseInitResponse EGCItemMsg = 2511 + EGCItemMsg_k_EMsgGCBannedWordListRequest EGCItemMsg = 2512 + EGCItemMsg_k_EMsgGCBannedWordListResponse EGCItemMsg = 2513 + EGCItemMsg_k_EMsgGCToGCBannedWordListBroadcast EGCItemMsg = 2514 + EGCItemMsg_k_EMsgGCToGCBannedWordListUpdated EGCItemMsg = 2515 + EGCItemMsg_k_EMsgGCToGCDirtySDOCache EGCItemMsg = 2516 + EGCItemMsg_k_EMsgGCToGCDirtyMultipleSDOCache EGCItemMsg = 2517 + EGCItemMsg_k_EMsgGCToGCUpdateSQLKeyValue EGCItemMsg = 2518 + EGCItemMsg_k_EMsgGCToGCBroadcastConsoleCommand EGCItemMsg = 2521 + EGCItemMsg_k_EMsgGCServerVersionUpdated EGCItemMsg = 2522 + EGCItemMsg_k_EMsgGCApplyAutograph EGCItemMsg = 2523 + EGCItemMsg_k_EMsgGCToGCWebAPIAccountChanged EGCItemMsg = 2524 + EGCItemMsg_k_EMsgGCClientVersionUpdated EGCItemMsg = 2528 + EGCItemMsg_k_EMsgGCItemPurgatory_FinalizePurchase EGCItemMsg = 2531 + EGCItemMsg_k_EMsgGCItemPurgatory_FinalizePurchaseResponse EGCItemMsg = 2532 + EGCItemMsg_k_EMsgGCItemPurgatory_RefundPurchase EGCItemMsg = 2533 + EGCItemMsg_k_EMsgGCItemPurgatory_RefundPurchaseResponse EGCItemMsg = 2534 + EGCItemMsg_k_EMsgGCToGCPlayerStrangeCountAdjustments EGCItemMsg = 2535 + EGCItemMsg_k_EMsgGCRequestStoreSalesData EGCItemMsg = 2536 + EGCItemMsg_k_EMsgGCRequestStoreSalesDataResponse EGCItemMsg = 2537 + EGCItemMsg_k_EMsgGCRequestStoreSalesDataUpToDateResponse EGCItemMsg = 2538 + EGCItemMsg_k_EMsgGCToGCPingRequest EGCItemMsg = 2539 + EGCItemMsg_k_EMsgGCToGCPingResponse EGCItemMsg = 2540 + EGCItemMsg_k_EMsgGCToGCGetUserSessionServer EGCItemMsg = 2541 + EGCItemMsg_k_EMsgGCToGCGetUserSessionServerResponse EGCItemMsg = 2542 + EGCItemMsg_k_EMsgGCToGCGetUserServerMembers EGCItemMsg = 2543 + EGCItemMsg_k_EMsgGCToGCGetUserServerMembersResponse EGCItemMsg = 2544 + EGCItemMsg_k_EMsgGCToGCGetUserPCBangNo EGCItemMsg = 2545 + EGCItemMsg_k_EMsgGCToGCGetUserPCBangNoResponse EGCItemMsg = 2546 + EGCItemMsg_k_EMsgGCToGCCanUseDropRateBonus EGCItemMsg = 2547 + EGCItemMsg_k_EMsgSQLAddDropRateBonus EGCItemMsg = 2548 + EGCItemMsg_k_EMsgGCToGCRefreshSOCache EGCItemMsg = 2549 + EGCItemMsg_k_EMsgGCToGCApplyLocalizationDiff EGCItemMsg = 2550 + EGCItemMsg_k_EMsgGCToGCApplyLocalizationDiffResponse EGCItemMsg = 2551 + EGCItemMsg_k_EMsgGCToGCCheckAccountTradeStatus EGCItemMsg = 2552 + EGCItemMsg_k_EMsgGCToGCCheckAccountTradeStatusResponse EGCItemMsg = 2553 + EGCItemMsg_k_EMsgGCToGCGrantAccountRolledItems EGCItemMsg = 2554 + EGCItemMsg_k_EMsgGCToGCGrantSelfMadeItemToAccount EGCItemMsg = 2555 + EGCItemMsg_k_EMsgSQLUpgradeBattleBooster EGCItemMsg = 2556 + EGCItemMsg_k_EMsgGCPartnerBalanceRequest EGCItemMsg = 2557 + EGCItemMsg_k_EMsgGCPartnerBalanceResponse EGCItemMsg = 2558 + EGCItemMsg_k_EMsgGCPartnerRechargeRedirectURLRequest EGCItemMsg = 2559 + EGCItemMsg_k_EMsgGCPartnerRechargeRedirectURLResponse EGCItemMsg = 2560 + EGCItemMsg_k_EMsgGCStatueCraft EGCItemMsg = 2561 + EGCItemMsg_k_EMsgGCRedeemCode EGCItemMsg = 2562 + EGCItemMsg_k_EMsgGCRedeemCodeResponse EGCItemMsg = 2563 + EGCItemMsg_k_EMsgGCToGCItemConsumptionRollback EGCItemMsg = 2564 + EGCItemMsg_k_EMsgClientToGCWrapAndDeliverGift EGCItemMsg = 2565 + EGCItemMsg_k_EMsgClientToGCWrapAndDeliverGiftResponse EGCItemMsg = 2566 + EGCItemMsg_k_EMsgClientToGCUnpackBundleResponse EGCItemMsg = 2567 + EGCItemMsg_k_EMsgGCToClientStoreTransactionCompleted EGCItemMsg = 2568 + EGCItemMsg_k_EMsgClientToGCEquipItems EGCItemMsg = 2569 + EGCItemMsg_k_EMsgClientToGCEquipItemsResponse EGCItemMsg = 2570 + EGCItemMsg_k_EMsgClientToGCUnlockItemStyle EGCItemMsg = 2571 + EGCItemMsg_k_EMsgClientToGCUnlockItemStyleResponse EGCItemMsg = 2572 + EGCItemMsg_k_EMsgClientToGCSetItemInventoryCategory EGCItemMsg = 2573 + EGCItemMsg_k_EMsgClientToGCUnlockCrate EGCItemMsg = 2574 + EGCItemMsg_k_EMsgClientToGCUnlockCrateResponse EGCItemMsg = 2575 + EGCItemMsg_k_EMsgClientToGCUnpackBundle EGCItemMsg = 2576 + EGCItemMsg_k_EMsgClientToGCSetItemStyle EGCItemMsg = 2577 + EGCItemMsg_k_EMsgClientToGCSetItemStyleResponse EGCItemMsg = 2578 + EGCItemMsg_k_EMsgGCGenericResult EGCItemMsg = 2579 + EGCItemMsg_k_EMsgSQLGCToGCGrantBackpackSlots EGCItemMsg = 2580 + EGCItemMsg_k_EMsgClientToGCLookupAccountName EGCItemMsg = 2581 + EGCItemMsg_k_EMsgClientToGCLookupAccountNameResponse EGCItemMsg = 2582 +) + +var EGCItemMsg_name = map[int32]string{ + 1000: "k_EMsgGCBase", + 1001: "k_EMsgGCSetItemPosition", + 1002: "k_EMsgGCCraft", + 1003: "k_EMsgGCCraftResponse", + 1004: "k_EMsgGCDelete", + 1005: "k_EMsgGCVerifyCacheSubscription", + 1006: "k_EMsgClientToGCNameItem", + 1009: "k_EMsgGCPaintItem", + 1010: "k_EMsgGCPaintItemResponse", + 1011: "k_EMsgGCGoldenWrenchBroadcast", + 1012: "k_EMsgGCMOTDRequest", + 1013: "k_EMsgGCMOTDRequestResponse", + 1014: "k_EMsgGCAddItemToSocket_DEPRECATED", + 1015: "k_EMsgGCAddItemToSocketResponse_DEPRECATED", + 1016: "k_EMsgGCAddSocketToBaseItem_DEPRECATED", + 1017: "k_EMsgGCAddSocketToItem_DEPRECATED", + 1018: "k_EMsgGCAddSocketToItemResponse_DEPRECATED", + 1019: "k_EMsgGCNameBaseItem", + 1020: "k_EMsgGCNameBaseItemResponse", + 1021: "k_EMsgGCRemoveSocketItem_DEPRECATED", + 1022: "k_EMsgGCRemoveSocketItemResponse_DEPRECATED", + 1023: "k_EMsgGCCustomizeItemTexture", + 1024: "k_EMsgGCCustomizeItemTextureResponse", + 1025: "k_EMsgGCUseItemRequest", + 1026: "k_EMsgGCUseItemResponse", + 1027: "k_EMsgGCGiftedItems", + 1030: "k_EMsgGCRemoveItemName", + 1031: "k_EMsgGCRemoveItemPaint", + 1037: "k_EMsgGCUnwrapGiftRequest", + 1038: "k_EMsgGCUnwrapGiftResponse", + 1039: "k_EMsgGCSetItemStyle_DEPRECATED", + 1040: "k_EMsgGCUsedClaimCodeItem", + 1041: "k_EMsgGCSortItems", + 1042: "k_EMsgGC_RevolvingLootList_DEPRECATED", + 1049: "k_EMsgGCUpdateItemSchema", + 1051: "k_EMsgGCRemoveCustomTexture", + 1052: "k_EMsgGCRemoveCustomTextureResponse", + 1053: "k_EMsgGCRemoveMakersMark", + 1054: "k_EMsgGCRemoveMakersMarkResponse", + 1055: "k_EMsgGCRemoveUniqueCraftIndex", + 1056: "k_EMsgGCRemoveUniqueCraftIndexResponse", + 1057: "k_EMsgGCSaxxyBroadcast", + 1058: "k_EMsgGCBackpackSortFinished", + 1059: "k_EMsgGCAdjustItemEquippedState", + 1061: "k_EMsgGCCollectItem", + 1062: "k_EMsgGCItemAcknowledged", + 1063: "k_EMsgGCPresets_SelectPresetForClass", + 1064: "k_EMsgGCPresets_SetItemPosition", + 1067: "k_EMsgGCPresets_SelectPresetForClassReply", + 1068: "k_EMsgClientToGCNameItemResponse", + 1069: "k_EMsgGCApplyConsumableEffects", + 1070: "k_EMsgGCConsumableExhausted", + 1071: "k_EMsgGCShowItemsPickedUp", + 1072: "k_EMsgGCClientDisplayNotification", + 1073: "k_EMsgGCApplyStrangePart", + 1075: "k_EMsgGC_IncrementKillCountResponse", + 1076: "k_EMsgGCApplyPennantUpgrade", + 1077: "k_EMsgGCSetItemPositions", + 1096: "k_EMsgGCSetItemPositions_RateLimited", + 1078: "k_EMsgGCApplyEggEssence", + 1079: "k_EMsgGCNameEggEssenceResponse", + 1082: "k_EMsgGCFulfillDynamicRecipeComponent", + 1083: "k_EMsgGCFulfillDynamicRecipeComponentResponse", + 1084: "k_EMsgGCClientRequestMarketData", + 1085: "k_EMsgGCClientRequestMarketDataResponse", + 1086: "k_EMsgGCExtractGems", + 1087: "k_EMsgGCAddSocket", + 1088: "k_EMsgGCAddItemToSocket", + 1089: "k_EMsgGCAddItemToSocketResponse", + 1090: "k_EMsgGCAddSocketResponse", + 1091: "k_EMsgGCResetStrangeGemCount", + 1092: "k_EMsgGCRequestCrateItems", + 1093: "k_EMsgGCRequestCrateItemsResponse", + 1094: "k_EMsgGCExtractGemsResponse", + 1095: "k_EMsgGCResetStrangeGemCountResponse", + 1103: "k_EMsgGCServerUseItemRequest", + 1104: "k_EMsgGCAddGiftItem", + 1105: "k_EMsgGCRemoveItemGiftMessage", + 1106: "k_EMsgGCRemoveItemGiftMessageResponse", + 1107: "k_EMsgGCRemoveItemGifterAccountId", + 1108: "k_EMsgGCRemoveItemGifterAccountIdResponse", + 1109: "k_EMsgClientToGCRemoveItemGifterAttributes", + 1110: "k_EMsgClientToGCRemoveItemName", + 1111: "k_EMsgClientToGCRemoveItemDescription", + 1112: "k_EMsgClientToGCRemoveItemAttributeResponse", + 1500: "k_EMsgGCTradingBase", + 1501: "k_EMsgGCTrading_InitiateTradeRequest", + 1502: "k_EMsgGCTrading_InitiateTradeResponse", + 1503: "k_EMsgGCTrading_StartSession", + 1509: "k_EMsgGCTrading_SessionClosed", + 1514: "k_EMsgGCTrading_InitiateTradeRequestResponse", + 1601: "k_EMsgGCServerBrowser_FavoriteServer", + 1602: "k_EMsgGCServerBrowser_BlacklistServer", + 1700: "k_EMsgGCServerRentalsBase", + 1701: "k_EMsgGCItemPreviewCheckStatus", + 1702: "k_EMsgGCItemPreviewStatusResponse", + 1703: "k_EMsgGCItemPreviewRequest", + 1704: "k_EMsgGCItemPreviewRequestResponse", + 1705: "k_EMsgGCItemPreviewExpire", + 1706: "k_EMsgGCItemPreviewExpireNotification", + 1707: "k_EMsgGCItemPreviewItemBoughtNotification", + 2001: "k_EMsgGCDev_NewItemRequest", + 2002: "k_EMsgGCDev_NewItemRequestResponse", + 2500: "k_EMsgGCStoreGetUserData", + 2501: "k_EMsgGCStoreGetUserDataResponse", + 2504: "k_EMsgGCStorePurchaseFinalize", + 2505: "k_EMsgGCStorePurchaseFinalizeResponse", + 2506: "k_EMsgGCStorePurchaseCancel", + 2507: "k_EMsgGCStorePurchaseCancelResponse", + 2510: "k_EMsgGCStorePurchaseInit", + 2511: "k_EMsgGCStorePurchaseInitResponse", + 2512: "k_EMsgGCBannedWordListRequest", + 2513: "k_EMsgGCBannedWordListResponse", + 2514: "k_EMsgGCToGCBannedWordListBroadcast", + 2515: "k_EMsgGCToGCBannedWordListUpdated", + 2516: "k_EMsgGCToGCDirtySDOCache", + 2517: "k_EMsgGCToGCDirtyMultipleSDOCache", + 2518: "k_EMsgGCToGCUpdateSQLKeyValue", + 2521: "k_EMsgGCToGCBroadcastConsoleCommand", + 2522: "k_EMsgGCServerVersionUpdated", + 2523: "k_EMsgGCApplyAutograph", + 2524: "k_EMsgGCToGCWebAPIAccountChanged", + 2528: "k_EMsgGCClientVersionUpdated", + 2531: "k_EMsgGCItemPurgatory_FinalizePurchase", + 2532: "k_EMsgGCItemPurgatory_FinalizePurchaseResponse", + 2533: "k_EMsgGCItemPurgatory_RefundPurchase", + 2534: "k_EMsgGCItemPurgatory_RefundPurchaseResponse", + 2535: "k_EMsgGCToGCPlayerStrangeCountAdjustments", + 2536: "k_EMsgGCRequestStoreSalesData", + 2537: "k_EMsgGCRequestStoreSalesDataResponse", + 2538: "k_EMsgGCRequestStoreSalesDataUpToDateResponse", + 2539: "k_EMsgGCToGCPingRequest", + 2540: "k_EMsgGCToGCPingResponse", + 2541: "k_EMsgGCToGCGetUserSessionServer", + 2542: "k_EMsgGCToGCGetUserSessionServerResponse", + 2543: "k_EMsgGCToGCGetUserServerMembers", + 2544: "k_EMsgGCToGCGetUserServerMembersResponse", + 2545: "k_EMsgGCToGCGetUserPCBangNo", + 2546: "k_EMsgGCToGCGetUserPCBangNoResponse", + 2547: "k_EMsgGCToGCCanUseDropRateBonus", + 2548: "k_EMsgSQLAddDropRateBonus", + 2549: "k_EMsgGCToGCRefreshSOCache", + 2550: "k_EMsgGCToGCApplyLocalizationDiff", + 2551: "k_EMsgGCToGCApplyLocalizationDiffResponse", + 2552: "k_EMsgGCToGCCheckAccountTradeStatus", + 2553: "k_EMsgGCToGCCheckAccountTradeStatusResponse", + 2554: "k_EMsgGCToGCGrantAccountRolledItems", + 2555: "k_EMsgGCToGCGrantSelfMadeItemToAccount", + 2556: "k_EMsgSQLUpgradeBattleBooster", + 2557: "k_EMsgGCPartnerBalanceRequest", + 2558: "k_EMsgGCPartnerBalanceResponse", + 2559: "k_EMsgGCPartnerRechargeRedirectURLRequest", + 2560: "k_EMsgGCPartnerRechargeRedirectURLResponse", + 2561: "k_EMsgGCStatueCraft", + 2562: "k_EMsgGCRedeemCode", + 2563: "k_EMsgGCRedeemCodeResponse", + 2564: "k_EMsgGCToGCItemConsumptionRollback", + 2565: "k_EMsgClientToGCWrapAndDeliverGift", + 2566: "k_EMsgClientToGCWrapAndDeliverGiftResponse", + 2567: "k_EMsgClientToGCUnpackBundleResponse", + 2568: "k_EMsgGCToClientStoreTransactionCompleted", + 2569: "k_EMsgClientToGCEquipItems", + 2570: "k_EMsgClientToGCEquipItemsResponse", + 2571: "k_EMsgClientToGCUnlockItemStyle", + 2572: "k_EMsgClientToGCUnlockItemStyleResponse", + 2573: "k_EMsgClientToGCSetItemInventoryCategory", + 2574: "k_EMsgClientToGCUnlockCrate", + 2575: "k_EMsgClientToGCUnlockCrateResponse", + 2576: "k_EMsgClientToGCUnpackBundle", + 2577: "k_EMsgClientToGCSetItemStyle", + 2578: "k_EMsgClientToGCSetItemStyleResponse", + 2579: "k_EMsgGCGenericResult", + 2580: "k_EMsgSQLGCToGCGrantBackpackSlots", + 2581: "k_EMsgClientToGCLookupAccountName", + 2582: "k_EMsgClientToGCLookupAccountNameResponse", +} +var EGCItemMsg_value = map[string]int32{ + "k_EMsgGCBase": 1000, + "k_EMsgGCSetItemPosition": 1001, + "k_EMsgGCCraft": 1002, + "k_EMsgGCCraftResponse": 1003, + "k_EMsgGCDelete": 1004, + "k_EMsgGCVerifyCacheSubscription": 1005, + "k_EMsgClientToGCNameItem": 1006, + "k_EMsgGCPaintItem": 1009, + "k_EMsgGCPaintItemResponse": 1010, + "k_EMsgGCGoldenWrenchBroadcast": 1011, + "k_EMsgGCMOTDRequest": 1012, + "k_EMsgGCMOTDRequestResponse": 1013, + "k_EMsgGCAddItemToSocket_DEPRECATED": 1014, + "k_EMsgGCAddItemToSocketResponse_DEPRECATED": 1015, + "k_EMsgGCAddSocketToBaseItem_DEPRECATED": 1016, + "k_EMsgGCAddSocketToItem_DEPRECATED": 1017, + "k_EMsgGCAddSocketToItemResponse_DEPRECATED": 1018, + "k_EMsgGCNameBaseItem": 1019, + "k_EMsgGCNameBaseItemResponse": 1020, + "k_EMsgGCRemoveSocketItem_DEPRECATED": 1021, + "k_EMsgGCRemoveSocketItemResponse_DEPRECATED": 1022, + "k_EMsgGCCustomizeItemTexture": 1023, + "k_EMsgGCCustomizeItemTextureResponse": 1024, + "k_EMsgGCUseItemRequest": 1025, + "k_EMsgGCUseItemResponse": 1026, + "k_EMsgGCGiftedItems": 1027, + "k_EMsgGCRemoveItemName": 1030, + "k_EMsgGCRemoveItemPaint": 1031, + "k_EMsgGCUnwrapGiftRequest": 1037, + "k_EMsgGCUnwrapGiftResponse": 1038, + "k_EMsgGCSetItemStyle_DEPRECATED": 1039, + "k_EMsgGCUsedClaimCodeItem": 1040, + "k_EMsgGCSortItems": 1041, + "k_EMsgGC_RevolvingLootList_DEPRECATED": 1042, + "k_EMsgGCUpdateItemSchema": 1049, + "k_EMsgGCRemoveCustomTexture": 1051, + "k_EMsgGCRemoveCustomTextureResponse": 1052, + "k_EMsgGCRemoveMakersMark": 1053, + "k_EMsgGCRemoveMakersMarkResponse": 1054, + "k_EMsgGCRemoveUniqueCraftIndex": 1055, + "k_EMsgGCRemoveUniqueCraftIndexResponse": 1056, + "k_EMsgGCSaxxyBroadcast": 1057, + "k_EMsgGCBackpackSortFinished": 1058, + "k_EMsgGCAdjustItemEquippedState": 1059, + "k_EMsgGCCollectItem": 1061, + "k_EMsgGCItemAcknowledged": 1062, + "k_EMsgGCPresets_SelectPresetForClass": 1063, + "k_EMsgGCPresets_SetItemPosition": 1064, + "k_EMsgGCPresets_SelectPresetForClassReply": 1067, + "k_EMsgClientToGCNameItemResponse": 1068, + "k_EMsgGCApplyConsumableEffects": 1069, + "k_EMsgGCConsumableExhausted": 1070, + "k_EMsgGCShowItemsPickedUp": 1071, + "k_EMsgGCClientDisplayNotification": 1072, + "k_EMsgGCApplyStrangePart": 1073, + "k_EMsgGC_IncrementKillCountResponse": 1075, + "k_EMsgGCApplyPennantUpgrade": 1076, + "k_EMsgGCSetItemPositions": 1077, + "k_EMsgGCSetItemPositions_RateLimited": 1096, + "k_EMsgGCApplyEggEssence": 1078, + "k_EMsgGCNameEggEssenceResponse": 1079, + "k_EMsgGCFulfillDynamicRecipeComponent": 1082, + "k_EMsgGCFulfillDynamicRecipeComponentResponse": 1083, + "k_EMsgGCClientRequestMarketData": 1084, + "k_EMsgGCClientRequestMarketDataResponse": 1085, + "k_EMsgGCExtractGems": 1086, + "k_EMsgGCAddSocket": 1087, + "k_EMsgGCAddItemToSocket": 1088, + "k_EMsgGCAddItemToSocketResponse": 1089, + "k_EMsgGCAddSocketResponse": 1090, + "k_EMsgGCResetStrangeGemCount": 1091, + "k_EMsgGCRequestCrateItems": 1092, + "k_EMsgGCRequestCrateItemsResponse": 1093, + "k_EMsgGCExtractGemsResponse": 1094, + "k_EMsgGCResetStrangeGemCountResponse": 1095, + "k_EMsgGCServerUseItemRequest": 1103, + "k_EMsgGCAddGiftItem": 1104, + "k_EMsgGCRemoveItemGiftMessage": 1105, + "k_EMsgGCRemoveItemGiftMessageResponse": 1106, + "k_EMsgGCRemoveItemGifterAccountId": 1107, + "k_EMsgGCRemoveItemGifterAccountIdResponse": 1108, + "k_EMsgClientToGCRemoveItemGifterAttributes": 1109, + "k_EMsgClientToGCRemoveItemName": 1110, + "k_EMsgClientToGCRemoveItemDescription": 1111, + "k_EMsgClientToGCRemoveItemAttributeResponse": 1112, + "k_EMsgGCTradingBase": 1500, + "k_EMsgGCTrading_InitiateTradeRequest": 1501, + "k_EMsgGCTrading_InitiateTradeResponse": 1502, + "k_EMsgGCTrading_StartSession": 1503, + "k_EMsgGCTrading_SessionClosed": 1509, + "k_EMsgGCTrading_InitiateTradeRequestResponse": 1514, + "k_EMsgGCServerBrowser_FavoriteServer": 1601, + "k_EMsgGCServerBrowser_BlacklistServer": 1602, + "k_EMsgGCServerRentalsBase": 1700, + "k_EMsgGCItemPreviewCheckStatus": 1701, + "k_EMsgGCItemPreviewStatusResponse": 1702, + "k_EMsgGCItemPreviewRequest": 1703, + "k_EMsgGCItemPreviewRequestResponse": 1704, + "k_EMsgGCItemPreviewExpire": 1705, + "k_EMsgGCItemPreviewExpireNotification": 1706, + "k_EMsgGCItemPreviewItemBoughtNotification": 1707, + "k_EMsgGCDev_NewItemRequest": 2001, + "k_EMsgGCDev_NewItemRequestResponse": 2002, + "k_EMsgGCStoreGetUserData": 2500, + "k_EMsgGCStoreGetUserDataResponse": 2501, + "k_EMsgGCStorePurchaseFinalize": 2504, + "k_EMsgGCStorePurchaseFinalizeResponse": 2505, + "k_EMsgGCStorePurchaseCancel": 2506, + "k_EMsgGCStorePurchaseCancelResponse": 2507, + "k_EMsgGCStorePurchaseInit": 2510, + "k_EMsgGCStorePurchaseInitResponse": 2511, + "k_EMsgGCBannedWordListRequest": 2512, + "k_EMsgGCBannedWordListResponse": 2513, + "k_EMsgGCToGCBannedWordListBroadcast": 2514, + "k_EMsgGCToGCBannedWordListUpdated": 2515, + "k_EMsgGCToGCDirtySDOCache": 2516, + "k_EMsgGCToGCDirtyMultipleSDOCache": 2517, + "k_EMsgGCToGCUpdateSQLKeyValue": 2518, + "k_EMsgGCToGCBroadcastConsoleCommand": 2521, + "k_EMsgGCServerVersionUpdated": 2522, + "k_EMsgGCApplyAutograph": 2523, + "k_EMsgGCToGCWebAPIAccountChanged": 2524, + "k_EMsgGCClientVersionUpdated": 2528, + "k_EMsgGCItemPurgatory_FinalizePurchase": 2531, + "k_EMsgGCItemPurgatory_FinalizePurchaseResponse": 2532, + "k_EMsgGCItemPurgatory_RefundPurchase": 2533, + "k_EMsgGCItemPurgatory_RefundPurchaseResponse": 2534, + "k_EMsgGCToGCPlayerStrangeCountAdjustments": 2535, + "k_EMsgGCRequestStoreSalesData": 2536, + "k_EMsgGCRequestStoreSalesDataResponse": 2537, + "k_EMsgGCRequestStoreSalesDataUpToDateResponse": 2538, + "k_EMsgGCToGCPingRequest": 2539, + "k_EMsgGCToGCPingResponse": 2540, + "k_EMsgGCToGCGetUserSessionServer": 2541, + "k_EMsgGCToGCGetUserSessionServerResponse": 2542, + "k_EMsgGCToGCGetUserServerMembers": 2543, + "k_EMsgGCToGCGetUserServerMembersResponse": 2544, + "k_EMsgGCToGCGetUserPCBangNo": 2545, + "k_EMsgGCToGCGetUserPCBangNoResponse": 2546, + "k_EMsgGCToGCCanUseDropRateBonus": 2547, + "k_EMsgSQLAddDropRateBonus": 2548, + "k_EMsgGCToGCRefreshSOCache": 2549, + "k_EMsgGCToGCApplyLocalizationDiff": 2550, + "k_EMsgGCToGCApplyLocalizationDiffResponse": 2551, + "k_EMsgGCToGCCheckAccountTradeStatus": 2552, + "k_EMsgGCToGCCheckAccountTradeStatusResponse": 2553, + "k_EMsgGCToGCGrantAccountRolledItems": 2554, + "k_EMsgGCToGCGrantSelfMadeItemToAccount": 2555, + "k_EMsgSQLUpgradeBattleBooster": 2556, + "k_EMsgGCPartnerBalanceRequest": 2557, + "k_EMsgGCPartnerBalanceResponse": 2558, + "k_EMsgGCPartnerRechargeRedirectURLRequest": 2559, + "k_EMsgGCPartnerRechargeRedirectURLResponse": 2560, + "k_EMsgGCStatueCraft": 2561, + "k_EMsgGCRedeemCode": 2562, + "k_EMsgGCRedeemCodeResponse": 2563, + "k_EMsgGCToGCItemConsumptionRollback": 2564, + "k_EMsgClientToGCWrapAndDeliverGift": 2565, + "k_EMsgClientToGCWrapAndDeliverGiftResponse": 2566, + "k_EMsgClientToGCUnpackBundleResponse": 2567, + "k_EMsgGCToClientStoreTransactionCompleted": 2568, + "k_EMsgClientToGCEquipItems": 2569, + "k_EMsgClientToGCEquipItemsResponse": 2570, + "k_EMsgClientToGCUnlockItemStyle": 2571, + "k_EMsgClientToGCUnlockItemStyleResponse": 2572, + "k_EMsgClientToGCSetItemInventoryCategory": 2573, + "k_EMsgClientToGCUnlockCrate": 2574, + "k_EMsgClientToGCUnlockCrateResponse": 2575, + "k_EMsgClientToGCUnpackBundle": 2576, + "k_EMsgClientToGCSetItemStyle": 2577, + "k_EMsgClientToGCSetItemStyleResponse": 2578, + "k_EMsgGCGenericResult": 2579, + "k_EMsgSQLGCToGCGrantBackpackSlots": 2580, + "k_EMsgClientToGCLookupAccountName": 2581, + "k_EMsgClientToGCLookupAccountNameResponse": 2582, +} + +func (x EGCItemMsg) Enum() *EGCItemMsg { + p := new(EGCItemMsg) + *p = x + return p +} +func (x EGCItemMsg) String() string { + return proto.EnumName(EGCItemMsg_name, int32(x)) +} +func (x *EGCItemMsg) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCItemMsg_value, data, "EGCItemMsg") + if err != nil { + return err + } + *x = EGCItemMsg(value) + return nil +} +func (EGCItemMsg) EnumDescriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{0} } + +type EGCMsgResponse int32 + +const ( + EGCMsgResponse_k_EGCMsgResponseOK EGCMsgResponse = 0 + EGCMsgResponse_k_EGCMsgResponseDenied EGCMsgResponse = 1 + EGCMsgResponse_k_EGCMsgResponseServerError EGCMsgResponse = 2 + EGCMsgResponse_k_EGCMsgResponseTimeout EGCMsgResponse = 3 + EGCMsgResponse_k_EGCMsgResponseInvalid EGCMsgResponse = 4 + EGCMsgResponse_k_EGCMsgResponseNoMatch EGCMsgResponse = 5 + EGCMsgResponse_k_EGCMsgResponseUnknownError EGCMsgResponse = 6 + EGCMsgResponse_k_EGCMsgResponseNotLoggedOn EGCMsgResponse = 7 + EGCMsgResponse_k_EGCMsgFailedToCreate EGCMsgResponse = 8 +) + +var EGCMsgResponse_name = map[int32]string{ + 0: "k_EGCMsgResponseOK", + 1: "k_EGCMsgResponseDenied", + 2: "k_EGCMsgResponseServerError", + 3: "k_EGCMsgResponseTimeout", + 4: "k_EGCMsgResponseInvalid", + 5: "k_EGCMsgResponseNoMatch", + 6: "k_EGCMsgResponseUnknownError", + 7: "k_EGCMsgResponseNotLoggedOn", + 8: "k_EGCMsgFailedToCreate", +} +var EGCMsgResponse_value = map[string]int32{ + "k_EGCMsgResponseOK": 0, + "k_EGCMsgResponseDenied": 1, + "k_EGCMsgResponseServerError": 2, + "k_EGCMsgResponseTimeout": 3, + "k_EGCMsgResponseInvalid": 4, + "k_EGCMsgResponseNoMatch": 5, + "k_EGCMsgResponseUnknownError": 6, + "k_EGCMsgResponseNotLoggedOn": 7, + "k_EGCMsgFailedToCreate": 8, +} + +func (x EGCMsgResponse) Enum() *EGCMsgResponse { + p := new(EGCMsgResponse) + *p = x + return p +} +func (x EGCMsgResponse) String() string { + return proto.EnumName(EGCMsgResponse_name, int32(x)) +} +func (x *EGCMsgResponse) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCMsgResponse_value, data, "EGCMsgResponse") + if err != nil { + return err + } + *x = EGCMsgResponse(value) + return nil +} +func (EGCMsgResponse) EnumDescriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{1} } + +type EItemPurgatoryResponse_Finalize int32 + +const ( + EItemPurgatoryResponse_Finalize_k_ItemPurgatoryResponse_Finalize_Succeeded EItemPurgatoryResponse_Finalize = 0 + EItemPurgatoryResponse_Finalize_k_ItemPurgatoryResponse_Finalize_Failed_Incomplete EItemPurgatoryResponse_Finalize = 1 + EItemPurgatoryResponse_Finalize_k_ItemPurgatoryResponse_Finalize_Failed_ItemsNotInPurgatory EItemPurgatoryResponse_Finalize = 2 + EItemPurgatoryResponse_Finalize_k_ItemPurgatoryResponse_Finalize_Failed_CouldNotFindItems EItemPurgatoryResponse_Finalize = 3 + EItemPurgatoryResponse_Finalize_k_ItemPurgatoryResponse_Finalize_Failed_NoSOCache EItemPurgatoryResponse_Finalize = 4 + EItemPurgatoryResponse_Finalize_k_ItemPurgatoryResponse_Finalize_BackpackFull EItemPurgatoryResponse_Finalize = 5 +) + +var EItemPurgatoryResponse_Finalize_name = map[int32]string{ + 0: "k_ItemPurgatoryResponse_Finalize_Succeeded", + 1: "k_ItemPurgatoryResponse_Finalize_Failed_Incomplete", + 2: "k_ItemPurgatoryResponse_Finalize_Failed_ItemsNotInPurgatory", + 3: "k_ItemPurgatoryResponse_Finalize_Failed_CouldNotFindItems", + 4: "k_ItemPurgatoryResponse_Finalize_Failed_NoSOCache", + 5: "k_ItemPurgatoryResponse_Finalize_BackpackFull", +} +var EItemPurgatoryResponse_Finalize_value = map[string]int32{ + "k_ItemPurgatoryResponse_Finalize_Succeeded": 0, + "k_ItemPurgatoryResponse_Finalize_Failed_Incomplete": 1, + "k_ItemPurgatoryResponse_Finalize_Failed_ItemsNotInPurgatory": 2, + "k_ItemPurgatoryResponse_Finalize_Failed_CouldNotFindItems": 3, + "k_ItemPurgatoryResponse_Finalize_Failed_NoSOCache": 4, + "k_ItemPurgatoryResponse_Finalize_BackpackFull": 5, +} + +func (x EItemPurgatoryResponse_Finalize) Enum() *EItemPurgatoryResponse_Finalize { + p := new(EItemPurgatoryResponse_Finalize) + *p = x + return p +} +func (x EItemPurgatoryResponse_Finalize) String() string { + return proto.EnumName(EItemPurgatoryResponse_Finalize_name, int32(x)) +} +func (x *EItemPurgatoryResponse_Finalize) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EItemPurgatoryResponse_Finalize_value, data, "EItemPurgatoryResponse_Finalize") + if err != nil { + return err + } + *x = EItemPurgatoryResponse_Finalize(value) + return nil +} +func (EItemPurgatoryResponse_Finalize) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{2} +} + +type EItemPurgatoryResponse_Refund int32 + +const ( + EItemPurgatoryResponse_Refund_k_ItemPurgatoryResponse_Refund_Succeeded EItemPurgatoryResponse_Refund = 0 + EItemPurgatoryResponse_Refund_k_ItemPurgatoryResponse_Refund_Failed_ItemNotInPurgatory EItemPurgatoryResponse_Refund = 1 + EItemPurgatoryResponse_Refund_k_ItemPurgatoryResponse_Refund_Failed_CouldNotFindItem EItemPurgatoryResponse_Refund = 2 + EItemPurgatoryResponse_Refund_k_ItemPurgatoryResponse_Refund_Failed_NoSOCache EItemPurgatoryResponse_Refund = 3 + EItemPurgatoryResponse_Refund_k_ItemPurgatoryResponse_Refund_Failed_NoDetail EItemPurgatoryResponse_Refund = 4 + EItemPurgatoryResponse_Refund_k_ItemPurgatoryResponse_Refund_Failed_NexonWebAPI EItemPurgatoryResponse_Refund = 5 +) + +var EItemPurgatoryResponse_Refund_name = map[int32]string{ + 0: "k_ItemPurgatoryResponse_Refund_Succeeded", + 1: "k_ItemPurgatoryResponse_Refund_Failed_ItemNotInPurgatory", + 2: "k_ItemPurgatoryResponse_Refund_Failed_CouldNotFindItem", + 3: "k_ItemPurgatoryResponse_Refund_Failed_NoSOCache", + 4: "k_ItemPurgatoryResponse_Refund_Failed_NoDetail", + 5: "k_ItemPurgatoryResponse_Refund_Failed_NexonWebAPI", +} +var EItemPurgatoryResponse_Refund_value = map[string]int32{ + "k_ItemPurgatoryResponse_Refund_Succeeded": 0, + "k_ItemPurgatoryResponse_Refund_Failed_ItemNotInPurgatory": 1, + "k_ItemPurgatoryResponse_Refund_Failed_CouldNotFindItem": 2, + "k_ItemPurgatoryResponse_Refund_Failed_NoSOCache": 3, + "k_ItemPurgatoryResponse_Refund_Failed_NoDetail": 4, + "k_ItemPurgatoryResponse_Refund_Failed_NexonWebAPI": 5, +} + +func (x EItemPurgatoryResponse_Refund) Enum() *EItemPurgatoryResponse_Refund { + p := new(EItemPurgatoryResponse_Refund) + *p = x + return p +} +func (x EItemPurgatoryResponse_Refund) String() string { + return proto.EnumName(EItemPurgatoryResponse_Refund_name, int32(x)) +} +func (x *EItemPurgatoryResponse_Refund) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EItemPurgatoryResponse_Refund_value, data, "EItemPurgatoryResponse_Refund") + if err != nil { + return err + } + *x = EItemPurgatoryResponse_Refund(value) + return nil +} +func (EItemPurgatoryResponse_Refund) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{3} +} + +type EGCPartnerRequestResponse int32 + +const ( + EGCPartnerRequestResponse_k_EPartnerRequestOK EGCPartnerRequestResponse = 1 + EGCPartnerRequestResponse_k_EPartnerRequestBadAccount EGCPartnerRequestResponse = 2 + EGCPartnerRequestResponse_k_EPartnerRequestNotLinked EGCPartnerRequestResponse = 3 + EGCPartnerRequestResponse_k_EPartnerRequestUnsupportedPartnerType EGCPartnerRequestResponse = 4 +) + +var EGCPartnerRequestResponse_name = map[int32]string{ + 1: "k_EPartnerRequestOK", + 2: "k_EPartnerRequestBadAccount", + 3: "k_EPartnerRequestNotLinked", + 4: "k_EPartnerRequestUnsupportedPartnerType", +} +var EGCPartnerRequestResponse_value = map[string]int32{ + "k_EPartnerRequestOK": 1, + "k_EPartnerRequestBadAccount": 2, + "k_EPartnerRequestNotLinked": 3, + "k_EPartnerRequestUnsupportedPartnerType": 4, +} + +func (x EGCPartnerRequestResponse) Enum() *EGCPartnerRequestResponse { + p := new(EGCPartnerRequestResponse) + *p = x + return p +} +func (x EGCPartnerRequestResponse) String() string { + return proto.EnumName(EGCPartnerRequestResponse_name, int32(x)) +} +func (x *EGCPartnerRequestResponse) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCPartnerRequestResponse_value, data, "EGCPartnerRequestResponse") + if err != nil { + return err + } + *x = EGCPartnerRequestResponse(value) + return nil +} +func (EGCPartnerRequestResponse) EnumDescriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{4} } + +type EGCMsgInitiateTradeResponse int32 + +const ( + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Accepted EGCMsgInitiateTradeResponse = 0 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Declined EGCMsgInitiateTradeResponse = 1 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_VAC_Banned_Initiator EGCMsgInitiateTradeResponse = 2 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_VAC_Banned_Target EGCMsgInitiateTradeResponse = 3 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Target_Already_Trading EGCMsgInitiateTradeResponse = 4 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Disabled EGCMsgInitiateTradeResponse = 5 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_NotLoggedIn EGCMsgInitiateTradeResponse = 6 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Cancel EGCMsgInitiateTradeResponse = 7 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_TooSoon EGCMsgInitiateTradeResponse = 8 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_TooSoonPenalty EGCMsgInitiateTradeResponse = 9 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Trade_Banned_Initiator EGCMsgInitiateTradeResponse = 10 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Trade_Banned_Target EGCMsgInitiateTradeResponse = 11 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Free_Account_Initiator_DEPRECATED EGCMsgInitiateTradeResponse = 12 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Shared_Account_Initiator EGCMsgInitiateTradeResponse = 13 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Service_Unavailable EGCMsgInitiateTradeResponse = 14 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Target_Blocked EGCMsgInitiateTradeResponse = 15 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_NeedVerifiedEmail EGCMsgInitiateTradeResponse = 16 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_NeedSteamGuard EGCMsgInitiateTradeResponse = 17 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_SteamGuardDuration EGCMsgInitiateTradeResponse = 18 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_TheyCannotTrade EGCMsgInitiateTradeResponse = 19 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Recent_Password_Reset EGCMsgInitiateTradeResponse = 20 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Using_New_Device EGCMsgInitiateTradeResponse = 21 + EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Sent_Invalid_Cookie EGCMsgInitiateTradeResponse = 22 +) + +var EGCMsgInitiateTradeResponse_name = map[int32]string{ + 0: "k_EGCMsgInitiateTradeResponse_Accepted", + 1: "k_EGCMsgInitiateTradeResponse_Declined", + 2: "k_EGCMsgInitiateTradeResponse_VAC_Banned_Initiator", + 3: "k_EGCMsgInitiateTradeResponse_VAC_Banned_Target", + 4: "k_EGCMsgInitiateTradeResponse_Target_Already_Trading", + 5: "k_EGCMsgInitiateTradeResponse_Disabled", + 6: "k_EGCMsgInitiateTradeResponse_NotLoggedIn", + 7: "k_EGCMsgInitiateTradeResponse_Cancel", + 8: "k_EGCMsgInitiateTradeResponse_TooSoon", + 9: "k_EGCMsgInitiateTradeResponse_TooSoonPenalty", + 10: "k_EGCMsgInitiateTradeResponse_Trade_Banned_Initiator", + 11: "k_EGCMsgInitiateTradeResponse_Trade_Banned_Target", + 12: "k_EGCMsgInitiateTradeResponse_Free_Account_Initiator_DEPRECATED", + 13: "k_EGCMsgInitiateTradeResponse_Shared_Account_Initiator", + 14: "k_EGCMsgInitiateTradeResponse_Service_Unavailable", + 15: "k_EGCMsgInitiateTradeResponse_Target_Blocked", + 16: "k_EGCMsgInitiateTradeResponse_NeedVerifiedEmail", + 17: "k_EGCMsgInitiateTradeResponse_NeedSteamGuard", + 18: "k_EGCMsgInitiateTradeResponse_SteamGuardDuration", + 19: "k_EGCMsgInitiateTradeResponse_TheyCannotTrade", + 20: "k_EGCMsgInitiateTradeResponse_Recent_Password_Reset", + 21: "k_EGCMsgInitiateTradeResponse_Using_New_Device", + 22: "k_EGCMsgInitiateTradeResponse_Sent_Invalid_Cookie", +} +var EGCMsgInitiateTradeResponse_value = map[string]int32{ + "k_EGCMsgInitiateTradeResponse_Accepted": 0, + "k_EGCMsgInitiateTradeResponse_Declined": 1, + "k_EGCMsgInitiateTradeResponse_VAC_Banned_Initiator": 2, + "k_EGCMsgInitiateTradeResponse_VAC_Banned_Target": 3, + "k_EGCMsgInitiateTradeResponse_Target_Already_Trading": 4, + "k_EGCMsgInitiateTradeResponse_Disabled": 5, + "k_EGCMsgInitiateTradeResponse_NotLoggedIn": 6, + "k_EGCMsgInitiateTradeResponse_Cancel": 7, + "k_EGCMsgInitiateTradeResponse_TooSoon": 8, + "k_EGCMsgInitiateTradeResponse_TooSoonPenalty": 9, + "k_EGCMsgInitiateTradeResponse_Trade_Banned_Initiator": 10, + "k_EGCMsgInitiateTradeResponse_Trade_Banned_Target": 11, + "k_EGCMsgInitiateTradeResponse_Free_Account_Initiator_DEPRECATED": 12, + "k_EGCMsgInitiateTradeResponse_Shared_Account_Initiator": 13, + "k_EGCMsgInitiateTradeResponse_Service_Unavailable": 14, + "k_EGCMsgInitiateTradeResponse_Target_Blocked": 15, + "k_EGCMsgInitiateTradeResponse_NeedVerifiedEmail": 16, + "k_EGCMsgInitiateTradeResponse_NeedSteamGuard": 17, + "k_EGCMsgInitiateTradeResponse_SteamGuardDuration": 18, + "k_EGCMsgInitiateTradeResponse_TheyCannotTrade": 19, + "k_EGCMsgInitiateTradeResponse_Recent_Password_Reset": 20, + "k_EGCMsgInitiateTradeResponse_Using_New_Device": 21, + "k_EGCMsgInitiateTradeResponse_Sent_Invalid_Cookie": 22, +} + +func (x EGCMsgInitiateTradeResponse) Enum() *EGCMsgInitiateTradeResponse { + p := new(EGCMsgInitiateTradeResponse) + *p = x + return p +} +func (x EGCMsgInitiateTradeResponse) String() string { + return proto.EnumName(EGCMsgInitiateTradeResponse_name, int32(x)) +} +func (x *EGCMsgInitiateTradeResponse) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCMsgInitiateTradeResponse_value, data, "EGCMsgInitiateTradeResponse") + if err != nil { + return err + } + *x = EGCMsgInitiateTradeResponse(value) + return nil +} +func (EGCMsgInitiateTradeResponse) EnumDescriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{5} } + +type CMsgRequestCrateItemsResponse_EResult int32 + +const ( + CMsgRequestCrateItemsResponse_k_Succeeded CMsgRequestCrateItemsResponse_EResult = 0 + CMsgRequestCrateItemsResponse_k_Failed CMsgRequestCrateItemsResponse_EResult = 1 +) + +var CMsgRequestCrateItemsResponse_EResult_name = map[int32]string{ + 0: "k_Succeeded", + 1: "k_Failed", +} +var CMsgRequestCrateItemsResponse_EResult_value = map[string]int32{ + "k_Succeeded": 0, + "k_Failed": 1, +} + +func (x CMsgRequestCrateItemsResponse_EResult) Enum() *CMsgRequestCrateItemsResponse_EResult { + p := new(CMsgRequestCrateItemsResponse_EResult) + *p = x + return p +} +func (x CMsgRequestCrateItemsResponse_EResult) String() string { + return proto.EnumName(CMsgRequestCrateItemsResponse_EResult_name, int32(x)) +} +func (x *CMsgRequestCrateItemsResponse_EResult) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgRequestCrateItemsResponse_EResult_value, data, "CMsgRequestCrateItemsResponse_EResult") + if err != nil { + return err + } + *x = CMsgRequestCrateItemsResponse_EResult(value) + return nil +} +func (CMsgRequestCrateItemsResponse_EResult) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{22, 0} +} + +type CMsgRedeemCodeResponse_EResultCode int32 + +const ( + CMsgRedeemCodeResponse_k_Succeeded CMsgRedeemCodeResponse_EResultCode = 0 + CMsgRedeemCodeResponse_k_Failed_CodeNotFound CMsgRedeemCodeResponse_EResultCode = 1 + CMsgRedeemCodeResponse_k_Failed_CodeAlreadyUsed CMsgRedeemCodeResponse_EResultCode = 2 + CMsgRedeemCodeResponse_k_Failed_OtherError CMsgRedeemCodeResponse_EResultCode = 3 +) + +var CMsgRedeemCodeResponse_EResultCode_name = map[int32]string{ + 0: "k_Succeeded", + 1: "k_Failed_CodeNotFound", + 2: "k_Failed_CodeAlreadyUsed", + 3: "k_Failed_OtherError", +} +var CMsgRedeemCodeResponse_EResultCode_value = map[string]int32{ + "k_Succeeded": 0, + "k_Failed_CodeNotFound": 1, + "k_Failed_CodeAlreadyUsed": 2, + "k_Failed_OtherError": 3, +} + +func (x CMsgRedeemCodeResponse_EResultCode) Enum() *CMsgRedeemCodeResponse_EResultCode { + p := new(CMsgRedeemCodeResponse_EResultCode) + *p = x + return p +} +func (x CMsgRedeemCodeResponse_EResultCode) String() string { + return proto.EnumName(CMsgRedeemCodeResponse_EResultCode_name, int32(x)) +} +func (x *CMsgRedeemCodeResponse_EResultCode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgRedeemCodeResponse_EResultCode_value, data, "CMsgRedeemCodeResponse_EResultCode") + if err != nil { + return err + } + *x = CMsgRedeemCodeResponse_EResultCode(value) + return nil +} +func (CMsgRedeemCodeResponse_EResultCode) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{41, 0} +} + +type CMsgClientToGCUnpackBundleResponse_EUnpackBundle int32 + +const ( + CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Succeeded CMsgClientToGCUnpackBundleResponse_EUnpackBundle = 0 + CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Failed_ItemIsNotBundle CMsgClientToGCUnpackBundleResponse_EUnpackBundle = 1 + CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Failed_UnableToCreateContainedItem CMsgClientToGCUnpackBundleResponse_EUnpackBundle = 2 + CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Failed_SOCacheError CMsgClientToGCUnpackBundleResponse_EUnpackBundle = 3 + CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Failed_ItemIsInvalid CMsgClientToGCUnpackBundleResponse_EUnpackBundle = 4 + CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Failed_BadItemQuantity CMsgClientToGCUnpackBundleResponse_EUnpackBundle = 5 + CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Failed_UnableToDeleteItem CMsgClientToGCUnpackBundleResponse_EUnpackBundle = 6 +) + +var CMsgClientToGCUnpackBundleResponse_EUnpackBundle_name = map[int32]string{ + 0: "k_UnpackBundle_Succeeded", + 1: "k_UnpackBundle_Failed_ItemIsNotBundle", + 2: "k_UnpackBundle_Failed_UnableToCreateContainedItem", + 3: "k_UnpackBundle_Failed_SOCacheError", + 4: "k_UnpackBundle_Failed_ItemIsInvalid", + 5: "k_UnpackBundle_Failed_BadItemQuantity", + 6: "k_UnpackBundle_Failed_UnableToDeleteItem", +} +var CMsgClientToGCUnpackBundleResponse_EUnpackBundle_value = map[string]int32{ + "k_UnpackBundle_Succeeded": 0, + "k_UnpackBundle_Failed_ItemIsNotBundle": 1, + "k_UnpackBundle_Failed_UnableToCreateContainedItem": 2, + "k_UnpackBundle_Failed_SOCacheError": 3, + "k_UnpackBundle_Failed_ItemIsInvalid": 4, + "k_UnpackBundle_Failed_BadItemQuantity": 5, + "k_UnpackBundle_Failed_UnableToDeleteItem": 6, +} + +func (x CMsgClientToGCUnpackBundleResponse_EUnpackBundle) Enum() *CMsgClientToGCUnpackBundleResponse_EUnpackBundle { + p := new(CMsgClientToGCUnpackBundleResponse_EUnpackBundle) + *p = x + return p +} +func (x CMsgClientToGCUnpackBundleResponse_EUnpackBundle) String() string { + return proto.EnumName(CMsgClientToGCUnpackBundleResponse_EUnpackBundle_name, int32(x)) +} +func (x *CMsgClientToGCUnpackBundleResponse_EUnpackBundle) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgClientToGCUnpackBundleResponse_EUnpackBundle_value, data, "CMsgClientToGCUnpackBundleResponse_EUnpackBundle") + if err != nil { + return err + } + *x = CMsgClientToGCUnpackBundleResponse_EUnpackBundle(value) + return nil +} +func (CMsgClientToGCUnpackBundleResponse_EUnpackBundle) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{49, 0} +} + +type CMsgClientToGCSetItemStyleResponse_ESetStyle int32 + +const ( + CMsgClientToGCSetItemStyleResponse_k_SetStyle_Succeeded CMsgClientToGCSetItemStyleResponse_ESetStyle = 0 + CMsgClientToGCSetItemStyleResponse_k_SetStyle_Failed CMsgClientToGCSetItemStyleResponse_ESetStyle = 1 + CMsgClientToGCSetItemStyleResponse_k_SetStyle_Failed_StyleIsLocked CMsgClientToGCSetItemStyleResponse_ESetStyle = 2 +) + +var CMsgClientToGCSetItemStyleResponse_ESetStyle_name = map[int32]string{ + 0: "k_SetStyle_Succeeded", + 1: "k_SetStyle_Failed", + 2: "k_SetStyle_Failed_StyleIsLocked", +} +var CMsgClientToGCSetItemStyleResponse_ESetStyle_value = map[string]int32{ + "k_SetStyle_Succeeded": 0, + "k_SetStyle_Failed": 1, + "k_SetStyle_Failed_StyleIsLocked": 2, +} + +func (x CMsgClientToGCSetItemStyleResponse_ESetStyle) Enum() *CMsgClientToGCSetItemStyleResponse_ESetStyle { + p := new(CMsgClientToGCSetItemStyleResponse_ESetStyle) + *p = x + return p +} +func (x CMsgClientToGCSetItemStyleResponse_ESetStyle) String() string { + return proto.EnumName(CMsgClientToGCSetItemStyleResponse_ESetStyle_name, int32(x)) +} +func (x *CMsgClientToGCSetItemStyleResponse_ESetStyle) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgClientToGCSetItemStyleResponse_ESetStyle_value, data, "CMsgClientToGCSetItemStyleResponse_ESetStyle") + if err != nil { + return err + } + *x = CMsgClientToGCSetItemStyleResponse_ESetStyle(value) + return nil +} +func (CMsgClientToGCSetItemStyleResponse_ESetStyle) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{54, 0} +} + +type CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle int32 + +const ( + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Succeeded CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 0 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_PreReq CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 1 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_CantAfford CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 2 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_CantCommit CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 3 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_CantLockCache CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 4 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_CantAffordAttrib CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 5 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_CantAffordGem CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 6 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_NoCompendiumLevel CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 7 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_AlreadyUnlocked CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 8 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_OtherError CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 9 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_ItemIsInvalid CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 10 + CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Failed_ToolIsInvalid CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = 11 +) + +var CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle_name = map[int32]string{ + 0: "k_UnlockStyle_Succeeded", + 1: "k_UnlockStyle_Failed_PreReq", + 2: "k_UnlockStyle_Failed_CantAfford", + 3: "k_UnlockStyle_Failed_CantCommit", + 4: "k_UnlockStyle_Failed_CantLockCache", + 5: "k_UnlockStyle_Failed_CantAffordAttrib", + 6: "k_UnlockStyle_Failed_CantAffordGem", + 7: "k_UnlockStyle_Failed_NoCompendiumLevel", + 8: "k_UnlockStyle_Failed_AlreadyUnlocked", + 9: "k_UnlockStyle_Failed_OtherError", + 10: "k_UnlockStyle_Failed_ItemIsInvalid", + 11: "k_UnlockStyle_Failed_ToolIsInvalid", +} +var CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle_value = map[string]int32{ + "k_UnlockStyle_Succeeded": 0, + "k_UnlockStyle_Failed_PreReq": 1, + "k_UnlockStyle_Failed_CantAfford": 2, + "k_UnlockStyle_Failed_CantCommit": 3, + "k_UnlockStyle_Failed_CantLockCache": 4, + "k_UnlockStyle_Failed_CantAffordAttrib": 5, + "k_UnlockStyle_Failed_CantAffordGem": 6, + "k_UnlockStyle_Failed_NoCompendiumLevel": 7, + "k_UnlockStyle_Failed_AlreadyUnlocked": 8, + "k_UnlockStyle_Failed_OtherError": 9, + "k_UnlockStyle_Failed_ItemIsInvalid": 10, + "k_UnlockStyle_Failed_ToolIsInvalid": 11, +} + +func (x CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle) Enum() *CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle { + p := new(CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle) + *p = x + return p +} +func (x CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle) String() string { + return proto.EnumName(CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle_name, int32(x)) +} +func (x *CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle_value, data, "CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle") + if err != nil { + return err + } + *x = CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle(value) + return nil +} +func (CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{56, 0} +} + +type CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute int32 + +const ( + CMsgClientToGCRemoveItemAttributeResponse_k_RemoveItemAttribute_Succeeded CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute = 0 + CMsgClientToGCRemoveItemAttributeResponse_k_RemoveItemAttribute_Failed CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute = 1 + CMsgClientToGCRemoveItemAttributeResponse_k_RemoveItemAttribute_Failed_ItemIsInvalid CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute = 2 + CMsgClientToGCRemoveItemAttributeResponse_k_RemoveItemAttribute_Failed_AttributeCannotBeRemoved CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute = 3 + CMsgClientToGCRemoveItemAttributeResponse_k_RemoveItemAttribute_Failed_AttributeDoesntExist CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute = 4 +) + +var CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute_name = map[int32]string{ + 0: "k_RemoveItemAttribute_Succeeded", + 1: "k_RemoveItemAttribute_Failed", + 2: "k_RemoveItemAttribute_Failed_ItemIsInvalid", + 3: "k_RemoveItemAttribute_Failed_AttributeCannotBeRemoved", + 4: "k_RemoveItemAttribute_Failed_AttributeDoesntExist", +} +var CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute_value = map[string]int32{ + "k_RemoveItemAttribute_Succeeded": 0, + "k_RemoveItemAttribute_Failed": 1, + "k_RemoveItemAttribute_Failed_ItemIsInvalid": 2, + "k_RemoveItemAttribute_Failed_AttributeCannotBeRemoved": 3, + "k_RemoveItemAttribute_Failed_AttributeDoesntExist": 4, +} + +func (x CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute) Enum() *CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute { + p := new(CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute) + *p = x + return p +} +func (x CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute) String() string { + return proto.EnumName(CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute_name, int32(x)) +} +func (x *CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute_value, data, "CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute") + if err != nil { + return err + } + *x = CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute(value) + return nil +} +func (CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{61, 0} +} + +type CMsgClientToGCNameItemResponse_ENameItem int32 + +const ( + CMsgClientToGCNameItemResponse_k_NameItem_Succeeded CMsgClientToGCNameItemResponse_ENameItem = 0 + CMsgClientToGCNameItemResponse_k_NameItem_Failed CMsgClientToGCNameItemResponse_ENameItem = 1 + CMsgClientToGCNameItemResponse_k_NameItem_Failed_ToolIsInvalid CMsgClientToGCNameItemResponse_ENameItem = 2 + CMsgClientToGCNameItemResponse_k_NameItem_Failed_ItemIsInvalid CMsgClientToGCNameItemResponse_ENameItem = 3 + CMsgClientToGCNameItemResponse_k_NameItem_Failed_NameIsInvalid CMsgClientToGCNameItemResponse_ENameItem = 4 +) + +var CMsgClientToGCNameItemResponse_ENameItem_name = map[int32]string{ + 0: "k_NameItem_Succeeded", + 1: "k_NameItem_Failed", + 2: "k_NameItem_Failed_ToolIsInvalid", + 3: "k_NameItem_Failed_ItemIsInvalid", + 4: "k_NameItem_Failed_NameIsInvalid", +} +var CMsgClientToGCNameItemResponse_ENameItem_value = map[string]int32{ + "k_NameItem_Succeeded": 0, + "k_NameItem_Failed": 1, + "k_NameItem_Failed_ToolIsInvalid": 2, + "k_NameItem_Failed_ItemIsInvalid": 3, + "k_NameItem_Failed_NameIsInvalid": 4, +} + +func (x CMsgClientToGCNameItemResponse_ENameItem) Enum() *CMsgClientToGCNameItemResponse_ENameItem { + p := new(CMsgClientToGCNameItemResponse_ENameItem) + *p = x + return p +} +func (x CMsgClientToGCNameItemResponse_ENameItem) String() string { + return proto.EnumName(CMsgClientToGCNameItemResponse_ENameItem_name, int32(x)) +} +func (x *CMsgClientToGCNameItemResponse_ENameItem) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(CMsgClientToGCNameItemResponse_ENameItem_value, data, "CMsgClientToGCNameItemResponse_ENameItem") + if err != nil { + return err + } + *x = CMsgClientToGCNameItemResponse_ENameItem(value) + return nil +} +func (CMsgClientToGCNameItemResponse_ENameItem) EnumDescriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{63, 0} +} + +type CMsgApplyAutograph struct { + AutographItemId *uint64 `protobuf:"varint,1,opt,name=autograph_item_id" json:"autograph_item_id,omitempty"` + ItemItemId *uint64 `protobuf:"varint,2,opt,name=item_item_id" json:"item_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgApplyAutograph) Reset() { *m = CMsgApplyAutograph{} } +func (m *CMsgApplyAutograph) String() string { return proto.CompactTextString(m) } +func (*CMsgApplyAutograph) ProtoMessage() {} +func (*CMsgApplyAutograph) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{0} } + +func (m *CMsgApplyAutograph) GetAutographItemId() uint64 { + if m != nil && m.AutographItemId != nil { + return *m.AutographItemId + } + return 0 +} + +func (m *CMsgApplyAutograph) GetItemItemId() uint64 { + if m != nil && m.ItemItemId != nil { + return *m.ItemItemId + } + return 0 +} + +type CMsgAdjustItemEquippedState struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + NewClass *uint32 `protobuf:"varint,2,opt,name=new_class" json:"new_class,omitempty"` + NewSlot *uint32 `protobuf:"varint,3,opt,name=new_slot" json:"new_slot,omitempty"` + StyleIndex *uint32 `protobuf:"varint,4,opt,name=style_index" json:"style_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAdjustItemEquippedState) Reset() { *m = CMsgAdjustItemEquippedState{} } +func (m *CMsgAdjustItemEquippedState) String() string { return proto.CompactTextString(m) } +func (*CMsgAdjustItemEquippedState) ProtoMessage() {} +func (*CMsgAdjustItemEquippedState) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{1} } + +func (m *CMsgAdjustItemEquippedState) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgAdjustItemEquippedState) GetNewClass() uint32 { + if m != nil && m.NewClass != nil { + return *m.NewClass + } + return 0 +} + +func (m *CMsgAdjustItemEquippedState) GetNewSlot() uint32 { + if m != nil && m.NewSlot != nil { + return *m.NewSlot + } + return 0 +} + +func (m *CMsgAdjustItemEquippedState) GetStyleIndex() uint32 { + if m != nil && m.StyleIndex != nil { + return *m.StyleIndex + } + return 0 +} + +type CMsgEconPlayerStrangeCountAdjustment struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + StrangeCountAdjustments []*CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment `protobuf:"bytes,2,rep,name=strange_count_adjustments" json:"strange_count_adjustments,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgEconPlayerStrangeCountAdjustment) Reset() { *m = CMsgEconPlayerStrangeCountAdjustment{} } +func (m *CMsgEconPlayerStrangeCountAdjustment) String() string { return proto.CompactTextString(m) } +func (*CMsgEconPlayerStrangeCountAdjustment) ProtoMessage() {} +func (*CMsgEconPlayerStrangeCountAdjustment) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{2} +} + +func (m *CMsgEconPlayerStrangeCountAdjustment) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgEconPlayerStrangeCountAdjustment) GetStrangeCountAdjustments() []*CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment { + if m != nil { + return m.StrangeCountAdjustments + } + return nil +} + +type CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment struct { + EventType *uint32 `protobuf:"varint,1,opt,name=event_type" json:"event_type,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + Adjustment *uint32 `protobuf:"varint,3,opt,name=adjustment" json:"adjustment,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment) Reset() { + *m = CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment{} +} +func (m *CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment) String() string { + return proto.CompactTextString(m) +} +func (*CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment) ProtoMessage() {} +func (*CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{2, 0} +} + +func (m *CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment) GetEventType() uint32 { + if m != nil && m.EventType != nil { + return *m.EventType + } + return 0 +} + +func (m *CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment) GetAdjustment() uint32 { + if m != nil && m.Adjustment != nil { + return *m.Adjustment + } + return 0 +} + +type CMsgRequestItemPurgatory_FinalizePurchase struct { + ItemIds []uint64 `protobuf:"varint,1,rep,name=item_ids" json:"item_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestItemPurgatory_FinalizePurchase) Reset() { + *m = CMsgRequestItemPurgatory_FinalizePurchase{} +} +func (m *CMsgRequestItemPurgatory_FinalizePurchase) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestItemPurgatory_FinalizePurchase) ProtoMessage() {} +func (*CMsgRequestItemPurgatory_FinalizePurchase) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{3} +} + +func (m *CMsgRequestItemPurgatory_FinalizePurchase) GetItemIds() []uint64 { + if m != nil { + return m.ItemIds + } + return nil +} + +type CMsgRequestItemPurgatory_FinalizePurchaseResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + ItemIds []uint64 `protobuf:"varint,2,rep,name=item_ids" json:"item_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestItemPurgatory_FinalizePurchaseResponse) Reset() { + *m = CMsgRequestItemPurgatory_FinalizePurchaseResponse{} +} +func (m *CMsgRequestItemPurgatory_FinalizePurchaseResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgRequestItemPurgatory_FinalizePurchaseResponse) ProtoMessage() {} +func (*CMsgRequestItemPurgatory_FinalizePurchaseResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{4} +} + +func (m *CMsgRequestItemPurgatory_FinalizePurchaseResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgRequestItemPurgatory_FinalizePurchaseResponse) GetItemIds() []uint64 { + if m != nil { + return m.ItemIds + } + return nil +} + +type CMsgRequestItemPurgatory_RefundPurchase struct { + ItemIds []uint64 `protobuf:"varint,1,rep,name=item_ids" json:"item_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestItemPurgatory_RefundPurchase) Reset() { + *m = CMsgRequestItemPurgatory_RefundPurchase{} +} +func (m *CMsgRequestItemPurgatory_RefundPurchase) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestItemPurgatory_RefundPurchase) ProtoMessage() {} +func (*CMsgRequestItemPurgatory_RefundPurchase) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{5} +} + +func (m *CMsgRequestItemPurgatory_RefundPurchase) GetItemIds() []uint64 { + if m != nil { + return m.ItemIds + } + return nil +} + +type CMsgRequestItemPurgatory_RefundPurchaseResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestItemPurgatory_RefundPurchaseResponse) Reset() { + *m = CMsgRequestItemPurgatory_RefundPurchaseResponse{} +} +func (m *CMsgRequestItemPurgatory_RefundPurchaseResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgRequestItemPurgatory_RefundPurchaseResponse) ProtoMessage() {} +func (*CMsgRequestItemPurgatory_RefundPurchaseResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{6} +} + +func (m *CMsgRequestItemPurgatory_RefundPurchaseResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgCraftingResponse struct { + ItemIds []uint64 `protobuf:"varint,1,rep,name=item_ids" json:"item_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCraftingResponse) Reset() { *m = CMsgCraftingResponse{} } +func (m *CMsgCraftingResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgCraftingResponse) ProtoMessage() {} +func (*CMsgCraftingResponse) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{7} } + +func (m *CMsgCraftingResponse) GetItemIds() []uint64 { + if m != nil { + return m.ItemIds + } + return nil +} + +type CMsgGCRequestStoreSalesData struct { + Version *uint32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"` + Currency *uint32 `protobuf:"varint,2,opt,name=currency" json:"currency,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCRequestStoreSalesData) Reset() { *m = CMsgGCRequestStoreSalesData{} } +func (m *CMsgGCRequestStoreSalesData) String() string { return proto.CompactTextString(m) } +func (*CMsgGCRequestStoreSalesData) ProtoMessage() {} +func (*CMsgGCRequestStoreSalesData) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{8} } + +func (m *CMsgGCRequestStoreSalesData) GetVersion() uint32 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgGCRequestStoreSalesData) GetCurrency() uint32 { + if m != nil && m.Currency != nil { + return *m.Currency + } + return 0 +} + +type CMsgGCRequestStoreSalesDataResponse struct { + SalePrice []*CMsgGCRequestStoreSalesDataResponse_Price `protobuf:"bytes,1,rep,name=sale_price" json:"sale_price,omitempty"` + Version *uint32 `protobuf:"varint,2,opt,name=version" json:"version,omitempty"` + ExpirationTime *uint32 `protobuf:"varint,3,opt,name=expiration_time" json:"expiration_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCRequestStoreSalesDataResponse) Reset() { *m = CMsgGCRequestStoreSalesDataResponse{} } +func (m *CMsgGCRequestStoreSalesDataResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCRequestStoreSalesDataResponse) ProtoMessage() {} +func (*CMsgGCRequestStoreSalesDataResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{9} +} + +func (m *CMsgGCRequestStoreSalesDataResponse) GetSalePrice() []*CMsgGCRequestStoreSalesDataResponse_Price { + if m != nil { + return m.SalePrice + } + return nil +} + +func (m *CMsgGCRequestStoreSalesDataResponse) GetVersion() uint32 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgGCRequestStoreSalesDataResponse) GetExpirationTime() uint32 { + if m != nil && m.ExpirationTime != nil { + return *m.ExpirationTime + } + return 0 +} + +type CMsgGCRequestStoreSalesDataResponse_Price struct { + ItemDef *uint32 `protobuf:"varint,1,opt,name=item_def" json:"item_def,omitempty"` + Price *uint32 `protobuf:"varint,2,opt,name=price" json:"price,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCRequestStoreSalesDataResponse_Price) Reset() { + *m = CMsgGCRequestStoreSalesDataResponse_Price{} +} +func (m *CMsgGCRequestStoreSalesDataResponse_Price) String() string { return proto.CompactTextString(m) } +func (*CMsgGCRequestStoreSalesDataResponse_Price) ProtoMessage() {} +func (*CMsgGCRequestStoreSalesDataResponse_Price) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{9, 0} +} + +func (m *CMsgGCRequestStoreSalesDataResponse_Price) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +func (m *CMsgGCRequestStoreSalesDataResponse_Price) GetPrice() uint32 { + if m != nil && m.Price != nil { + return *m.Price + } + return 0 +} + +type CMsgGCRequestStoreSalesDataUpToDateResponse struct { + Version *uint32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"` + ExpirationTime *uint32 `protobuf:"varint,2,opt,name=expiration_time" json:"expiration_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCRequestStoreSalesDataUpToDateResponse) Reset() { + *m = CMsgGCRequestStoreSalesDataUpToDateResponse{} +} +func (m *CMsgGCRequestStoreSalesDataUpToDateResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCRequestStoreSalesDataUpToDateResponse) ProtoMessage() {} +func (*CMsgGCRequestStoreSalesDataUpToDateResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{10} +} + +func (m *CMsgGCRequestStoreSalesDataUpToDateResponse) GetVersion() uint32 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgGCRequestStoreSalesDataUpToDateResponse) GetExpirationTime() uint32 { + if m != nil && m.ExpirationTime != nil { + return *m.ExpirationTime + } + return 0 +} + +type CMsgGCToGCPingRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCPingRequest) Reset() { *m = CMsgGCToGCPingRequest{} } +func (m *CMsgGCToGCPingRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCPingRequest) ProtoMessage() {} +func (*CMsgGCToGCPingRequest) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{11} } + +type CMsgGCToGCPingResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCPingResponse) Reset() { *m = CMsgGCToGCPingResponse{} } +func (m *CMsgGCToGCPingResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCPingResponse) ProtoMessage() {} +func (*CMsgGCToGCPingResponse) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{12} } + +type CMsgGCToGCGetUserSessionServer struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGetUserSessionServer) Reset() { *m = CMsgGCToGCGetUserSessionServer{} } +func (m *CMsgGCToGCGetUserSessionServer) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGetUserSessionServer) ProtoMessage() {} +func (*CMsgGCToGCGetUserSessionServer) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{13} } + +func (m *CMsgGCToGCGetUserSessionServer) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgGCToGCGetUserSessionServerResponse struct { + ServerSteamId *uint64 `protobuf:"fixed64,1,opt,name=server_steam_id" json:"server_steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGetUserSessionServerResponse) Reset() { + *m = CMsgGCToGCGetUserSessionServerResponse{} +} +func (m *CMsgGCToGCGetUserSessionServerResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGetUserSessionServerResponse) ProtoMessage() {} +func (*CMsgGCToGCGetUserSessionServerResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{14} +} + +func (m *CMsgGCToGCGetUserSessionServerResponse) GetServerSteamId() uint64 { + if m != nil && m.ServerSteamId != nil { + return *m.ServerSteamId + } + return 0 +} + +type CMsgGCToGCGetUserServerMembers struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + MaxSpectators *uint32 `protobuf:"varint,2,opt,name=max_spectators" json:"max_spectators,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGetUserServerMembers) Reset() { *m = CMsgGCToGCGetUserServerMembers{} } +func (m *CMsgGCToGCGetUserServerMembers) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGetUserServerMembers) ProtoMessage() {} +func (*CMsgGCToGCGetUserServerMembers) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{15} } + +func (m *CMsgGCToGCGetUserServerMembers) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToGCGetUserServerMembers) GetMaxSpectators() uint32 { + if m != nil && m.MaxSpectators != nil { + return *m.MaxSpectators + } + return 0 +} + +type CMsgGCToGCGetUserServerMembersResponse struct { + MemberAccountId []uint32 `protobuf:"varint,1,rep,name=member_account_id" json:"member_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGetUserServerMembersResponse) Reset() { + *m = CMsgGCToGCGetUserServerMembersResponse{} +} +func (m *CMsgGCToGCGetUserServerMembersResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGetUserServerMembersResponse) ProtoMessage() {} +func (*CMsgGCToGCGetUserServerMembersResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{16} +} + +func (m *CMsgGCToGCGetUserServerMembersResponse) GetMemberAccountId() []uint32 { + if m != nil { + return m.MemberAccountId + } + return nil +} + +type CMsgLookupMultipleAccountNames struct { + Accountids []uint32 `protobuf:"varint,1,rep,packed,name=accountids" json:"accountids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLookupMultipleAccountNames) Reset() { *m = CMsgLookupMultipleAccountNames{} } +func (m *CMsgLookupMultipleAccountNames) String() string { return proto.CompactTextString(m) } +func (*CMsgLookupMultipleAccountNames) ProtoMessage() {} +func (*CMsgLookupMultipleAccountNames) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{17} } + +func (m *CMsgLookupMultipleAccountNames) GetAccountids() []uint32 { + if m != nil { + return m.Accountids + } + return nil +} + +type CMsgLookupMultipleAccountNamesResponse struct { + Accounts []*CMsgLookupMultipleAccountNamesResponse_Account `protobuf:"bytes,1,rep,name=accounts" json:"accounts,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLookupMultipleAccountNamesResponse) Reset() { + *m = CMsgLookupMultipleAccountNamesResponse{} +} +func (m *CMsgLookupMultipleAccountNamesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgLookupMultipleAccountNamesResponse) ProtoMessage() {} +func (*CMsgLookupMultipleAccountNamesResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{18} +} + +func (m *CMsgLookupMultipleAccountNamesResponse) GetAccounts() []*CMsgLookupMultipleAccountNamesResponse_Account { + if m != nil { + return m.Accounts + } + return nil +} + +type CMsgLookupMultipleAccountNamesResponse_Account struct { + Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"` + Persona *string `protobuf:"bytes,2,opt,name=persona" json:"persona,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgLookupMultipleAccountNamesResponse_Account) Reset() { + *m = CMsgLookupMultipleAccountNamesResponse_Account{} +} +func (m *CMsgLookupMultipleAccountNamesResponse_Account) String() string { + return proto.CompactTextString(m) +} +func (*CMsgLookupMultipleAccountNamesResponse_Account) ProtoMessage() {} +func (*CMsgLookupMultipleAccountNamesResponse_Account) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{18, 0} +} + +func (m *CMsgLookupMultipleAccountNamesResponse_Account) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +func (m *CMsgLookupMultipleAccountNamesResponse_Account) GetPersona() string { + if m != nil && m.Persona != nil { + return *m.Persona + } + return "" +} + +type CMsgGCToGCGetUserPCBangNo struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGetUserPCBangNo) Reset() { *m = CMsgGCToGCGetUserPCBangNo{} } +func (m *CMsgGCToGCGetUserPCBangNo) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGetUserPCBangNo) ProtoMessage() {} +func (*CMsgGCToGCGetUserPCBangNo) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{19} } + +func (m *CMsgGCToGCGetUserPCBangNo) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgGCToGCGetUserPCBangNoResponse struct { + PcBangNo *uint32 `protobuf:"varint,1,opt,name=pc_bang_no" json:"pc_bang_no,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGetUserPCBangNoResponse) Reset() { *m = CMsgGCToGCGetUserPCBangNoResponse{} } +func (m *CMsgGCToGCGetUserPCBangNoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGetUserPCBangNoResponse) ProtoMessage() {} +func (*CMsgGCToGCGetUserPCBangNoResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{20} +} + +func (m *CMsgGCToGCGetUserPCBangNoResponse) GetPcBangNo() uint32 { + if m != nil && m.PcBangNo != nil { + return *m.PcBangNo + } + return 0 +} + +type CMsgRequestCrateItems struct { + CrateItemDef *uint32 `protobuf:"varint,1,opt,name=crate_item_def" json:"crate_item_def,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestCrateItems) Reset() { *m = CMsgRequestCrateItems{} } +func (m *CMsgRequestCrateItems) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestCrateItems) ProtoMessage() {} +func (*CMsgRequestCrateItems) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{21} } + +func (m *CMsgRequestCrateItems) GetCrateItemDef() uint32 { + if m != nil && m.CrateItemDef != nil { + return *m.CrateItemDef + } + return 0 +} + +type CMsgRequestCrateItemsResponse struct { + Response *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"` + ItemDefs []uint32 `protobuf:"varint,2,rep,name=item_defs" json:"item_defs,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRequestCrateItemsResponse) Reset() { *m = CMsgRequestCrateItemsResponse{} } +func (m *CMsgRequestCrateItemsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgRequestCrateItemsResponse) ProtoMessage() {} +func (*CMsgRequestCrateItemsResponse) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{22} } + +func (m *CMsgRequestCrateItemsResponse) GetResponse() uint32 { + if m != nil && m.Response != nil { + return *m.Response + } + return 0 +} + +func (m *CMsgRequestCrateItemsResponse) GetItemDefs() []uint32 { + if m != nil { + return m.ItemDefs + } + return nil +} + +type CMsgGCToGCCanUseDropRateBonus struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + DropRateBonus *float32 `protobuf:"fixed32,2,opt,name=drop_rate_bonus" json:"drop_rate_bonus,omitempty"` + BoosterType *uint32 `protobuf:"varint,3,opt,name=booster_type" json:"booster_type,omitempty"` + ExclusiveItemDef *uint32 `protobuf:"varint,4,opt,name=exclusive_item_def" json:"exclusive_item_def,omitempty"` + AllowEqualRate *bool `protobuf:"varint,5,opt,name=allow_equal_rate" json:"allow_equal_rate,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCCanUseDropRateBonus) Reset() { *m = CMsgGCToGCCanUseDropRateBonus{} } +func (m *CMsgGCToGCCanUseDropRateBonus) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCCanUseDropRateBonus) ProtoMessage() {} +func (*CMsgGCToGCCanUseDropRateBonus) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{23} } + +func (m *CMsgGCToGCCanUseDropRateBonus) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToGCCanUseDropRateBonus) GetDropRateBonus() float32 { + if m != nil && m.DropRateBonus != nil { + return *m.DropRateBonus + } + return 0 +} + +func (m *CMsgGCToGCCanUseDropRateBonus) GetBoosterType() uint32 { + if m != nil && m.BoosterType != nil { + return *m.BoosterType + } + return 0 +} + +func (m *CMsgGCToGCCanUseDropRateBonus) GetExclusiveItemDef() uint32 { + if m != nil && m.ExclusiveItemDef != nil { + return *m.ExclusiveItemDef + } + return 0 +} + +func (m *CMsgGCToGCCanUseDropRateBonus) GetAllowEqualRate() bool { + if m != nil && m.AllowEqualRate != nil { + return *m.AllowEqualRate + } + return false +} + +type CMsgSQLAddDropRateBonus struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + ItemDef *uint32 `protobuf:"varint,3,opt,name=item_def" json:"item_def,omitempty"` + DropRateBonus *float32 `protobuf:"fixed32,4,opt,name=drop_rate_bonus" json:"drop_rate_bonus,omitempty"` + BoosterType *uint32 `protobuf:"varint,5,opt,name=booster_type" json:"booster_type,omitempty"` + SecondsDuration *uint32 `protobuf:"varint,6,opt,name=seconds_duration" json:"seconds_duration,omitempty"` + EndTimeStamp *uint32 `protobuf:"varint,7,opt,name=end_time_stamp" json:"end_time_stamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSQLAddDropRateBonus) Reset() { *m = CMsgSQLAddDropRateBonus{} } +func (m *CMsgSQLAddDropRateBonus) String() string { return proto.CompactTextString(m) } +func (*CMsgSQLAddDropRateBonus) ProtoMessage() {} +func (*CMsgSQLAddDropRateBonus) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{24} } + +func (m *CMsgSQLAddDropRateBonus) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgSQLAddDropRateBonus) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgSQLAddDropRateBonus) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +func (m *CMsgSQLAddDropRateBonus) GetDropRateBonus() float32 { + if m != nil && m.DropRateBonus != nil { + return *m.DropRateBonus + } + return 0 +} + +func (m *CMsgSQLAddDropRateBonus) GetBoosterType() uint32 { + if m != nil && m.BoosterType != nil { + return *m.BoosterType + } + return 0 +} + +func (m *CMsgSQLAddDropRateBonus) GetSecondsDuration() uint32 { + if m != nil && m.SecondsDuration != nil { + return *m.SecondsDuration + } + return 0 +} + +func (m *CMsgSQLAddDropRateBonus) GetEndTimeStamp() uint32 { + if m != nil && m.EndTimeStamp != nil { + return *m.EndTimeStamp + } + return 0 +} + +type CMsgSQLUpgradeBattleBooster struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ItemDef *uint32 `protobuf:"varint,2,opt,name=item_def" json:"item_def,omitempty"` + BonusToAdd *float32 `protobuf:"fixed32,3,opt,name=bonus_to_add" json:"bonus_to_add,omitempty"` + BoosterType *uint32 `protobuf:"varint,4,opt,name=booster_type" json:"booster_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSQLUpgradeBattleBooster) Reset() { *m = CMsgSQLUpgradeBattleBooster{} } +func (m *CMsgSQLUpgradeBattleBooster) String() string { return proto.CompactTextString(m) } +func (*CMsgSQLUpgradeBattleBooster) ProtoMessage() {} +func (*CMsgSQLUpgradeBattleBooster) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{25} } + +func (m *CMsgSQLUpgradeBattleBooster) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgSQLUpgradeBattleBooster) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +func (m *CMsgSQLUpgradeBattleBooster) GetBonusToAdd() float32 { + if m != nil && m.BonusToAdd != nil { + return *m.BonusToAdd + } + return 0 +} + +func (m *CMsgSQLUpgradeBattleBooster) GetBoosterType() uint32 { + if m != nil && m.BoosterType != nil { + return *m.BoosterType + } + return 0 +} + +type CMsgGCToGCRefreshSOCache struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Reload *bool `protobuf:"varint,2,opt,name=reload" json:"reload,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCRefreshSOCache) Reset() { *m = CMsgGCToGCRefreshSOCache{} } +func (m *CMsgGCToGCRefreshSOCache) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCRefreshSOCache) ProtoMessage() {} +func (*CMsgGCToGCRefreshSOCache) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{26} } + +func (m *CMsgGCToGCRefreshSOCache) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToGCRefreshSOCache) GetReload() bool { + if m != nil && m.Reload != nil { + return *m.Reload + } + return false +} + +type CMsgGCToGCCheckAccountTradeStatus struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Initiator *bool `protobuf:"varint,2,opt,name=initiator" json:"initiator,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCCheckAccountTradeStatus) Reset() { *m = CMsgGCToGCCheckAccountTradeStatus{} } +func (m *CMsgGCToGCCheckAccountTradeStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCCheckAccountTradeStatus) ProtoMessage() {} +func (*CMsgGCToGCCheckAccountTradeStatus) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{27} +} + +func (m *CMsgGCToGCCheckAccountTradeStatus) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToGCCheckAccountTradeStatus) GetInitiator() bool { + if m != nil && m.Initiator != nil { + return *m.Initiator + } + return false +} + +type CMsgGCToGCCheckAccountTradeStatusResponse struct { + CanTrade *bool `protobuf:"varint,1,opt,name=can_trade" json:"can_trade,omitempty"` + ErrorCode *uint32 `protobuf:"varint,2,opt,name=error_code" json:"error_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCCheckAccountTradeStatusResponse) Reset() { + *m = CMsgGCToGCCheckAccountTradeStatusResponse{} +} +func (m *CMsgGCToGCCheckAccountTradeStatusResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCCheckAccountTradeStatusResponse) ProtoMessage() {} +func (*CMsgGCToGCCheckAccountTradeStatusResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{28} +} + +func (m *CMsgGCToGCCheckAccountTradeStatusResponse) GetCanTrade() bool { + if m != nil && m.CanTrade != nil { + return *m.CanTrade + } + return false +} + +func (m *CMsgGCToGCCheckAccountTradeStatusResponse) GetErrorCode() uint32 { + if m != nil && m.ErrorCode != nil { + return *m.ErrorCode + } + return 0 +} + +type CMsgGCToGCGrantAccountRolledItems struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + Items []*CMsgGCToGCGrantAccountRolledItems_Item `protobuf:"bytes,2,rep,name=items" json:"items,omitempty"` + AuditAction *uint32 `protobuf:"varint,3,opt,name=audit_action" json:"audit_action,omitempty"` + AuditData *uint32 `protobuf:"varint,4,opt,name=audit_data" json:"audit_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGrantAccountRolledItems) Reset() { *m = CMsgGCToGCGrantAccountRolledItems{} } +func (m *CMsgGCToGCGrantAccountRolledItems) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGrantAccountRolledItems) ProtoMessage() {} +func (*CMsgGCToGCGrantAccountRolledItems) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{29} +} + +func (m *CMsgGCToGCGrantAccountRolledItems) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCToGCGrantAccountRolledItems) GetItems() []*CMsgGCToGCGrantAccountRolledItems_Item { + if m != nil { + return m.Items + } + return nil +} + +func (m *CMsgGCToGCGrantAccountRolledItems) GetAuditAction() uint32 { + if m != nil && m.AuditAction != nil { + return *m.AuditAction + } + return 0 +} + +func (m *CMsgGCToGCGrantAccountRolledItems) GetAuditData() uint32 { + if m != nil && m.AuditData != nil { + return *m.AuditData + } + return 0 +} + +type CMsgGCToGCGrantAccountRolledItems_Item struct { + ItemDef *uint32 `protobuf:"varint,1,opt,name=item_def" json:"item_def,omitempty"` + LootLists []string `protobuf:"bytes,2,rep,name=loot_lists" json:"loot_lists,omitempty"` + IgnoreLimit *bool `protobuf:"varint,3,opt,name=ignore_limit" json:"ignore_limit,omitempty"` + Origin *uint32 `protobuf:"varint,4,opt,name=origin" json:"origin,omitempty"` + DynamicAttributes []*CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute `protobuf:"bytes,5,rep,name=dynamic_attributes" json:"dynamic_attributes,omitempty"` + AdditionalAuditEntries []*CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry `protobuf:"bytes,6,rep,name=additional_audit_entries" json:"additional_audit_entries,omitempty"` + InventoryToken *uint32 `protobuf:"varint,7,opt,name=inventory_token" json:"inventory_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) Reset() { + *m = CMsgGCToGCGrantAccountRolledItems_Item{} +} +func (m *CMsgGCToGCGrantAccountRolledItems_Item) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGrantAccountRolledItems_Item) ProtoMessage() {} +func (*CMsgGCToGCGrantAccountRolledItems_Item) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{29, 0} +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) GetLootLists() []string { + if m != nil { + return m.LootLists + } + return nil +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) GetIgnoreLimit() bool { + if m != nil && m.IgnoreLimit != nil { + return *m.IgnoreLimit + } + return false +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) GetOrigin() uint32 { + if m != nil && m.Origin != nil { + return *m.Origin + } + return 0 +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) GetDynamicAttributes() []*CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute { + if m != nil { + return m.DynamicAttributes + } + return nil +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) GetAdditionalAuditEntries() []*CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry { + if m != nil { + return m.AdditionalAuditEntries + } + return nil +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item) GetInventoryToken() uint32 { + if m != nil && m.InventoryToken != nil { + return *m.InventoryToken + } + return 0 +} + +type CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + ValueUint32 *uint32 `protobuf:"varint,2,opt,name=value_uint32" json:"value_uint32,omitempty"` + ValueFloat *float32 `protobuf:"fixed32,3,opt,name=value_float" json:"value_float,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute) Reset() { + *m = CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute{} +} +func (m *CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute) ProtoMessage() {} +func (*CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{29, 0, 0} +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute) GetValueUint32() uint32 { + if m != nil && m.ValueUint32 != nil { + return *m.ValueUint32 + } + return 0 +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute) GetValueFloat() float32 { + if m != nil && m.ValueFloat != nil { + return *m.ValueFloat + } + return 0 +} + +type CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry struct { + OwnerAccountId *uint32 `protobuf:"varint,1,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + AuditAction *uint32 `protobuf:"varint,2,opt,name=audit_action" json:"audit_action,omitempty"` + AuditData *uint32 `protobuf:"varint,3,opt,name=audit_data" json:"audit_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry) Reset() { + *m = CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry{} +} +func (m *CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry) ProtoMessage() {} +func (*CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{29, 0, 1} +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry) GetAuditAction() uint32 { + if m != nil && m.AuditAction != nil { + return *m.AuditAction + } + return 0 +} + +func (m *CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry) GetAuditData() uint32 { + if m != nil && m.AuditData != nil { + return *m.AuditData + } + return 0 +} + +type CMsgGCToGCGrantSelfMadeItemToAccount struct { + ItemDefIndex *uint32 `protobuf:"varint,1,opt,name=item_def_index" json:"item_def_index,omitempty"` + Accountid *uint32 `protobuf:"varint,2,opt,name=accountid" json:"accountid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCGrantSelfMadeItemToAccount) Reset() { *m = CMsgGCToGCGrantSelfMadeItemToAccount{} } +func (m *CMsgGCToGCGrantSelfMadeItemToAccount) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCGrantSelfMadeItemToAccount) ProtoMessage() {} +func (*CMsgGCToGCGrantSelfMadeItemToAccount) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{30} +} + +func (m *CMsgGCToGCGrantSelfMadeItemToAccount) GetItemDefIndex() uint32 { + if m != nil && m.ItemDefIndex != nil { + return *m.ItemDefIndex + } + return 0 +} + +func (m *CMsgGCToGCGrantSelfMadeItemToAccount) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +type CMsgUseItem struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + TargetSteamId *uint64 `protobuf:"fixed64,2,opt,name=target_steam_id" json:"target_steam_id,omitempty"` + Gift_PotentialTargets []uint32 `protobuf:"varint,3,rep,name=gift__potential_targets" json:"gift__potential_targets,omitempty"` + Duel_ClassLock *uint32 `protobuf:"varint,4,opt,name=duel__class_lock" json:"duel__class_lock,omitempty"` + InitiatorSteamId *uint64 `protobuf:"varint,5,opt,name=initiator_steam_id" json:"initiator_steam_id,omitempty"` + Itempack_AckImmediately *bool `protobuf:"varint,6,opt,name=itempack__ack_immediately" json:"itempack__ack_immediately,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgUseItem) Reset() { *m = CMsgUseItem{} } +func (m *CMsgUseItem) String() string { return proto.CompactTextString(m) } +func (*CMsgUseItem) ProtoMessage() {} +func (*CMsgUseItem) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{31} } + +func (m *CMsgUseItem) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgUseItem) GetTargetSteamId() uint64 { + if m != nil && m.TargetSteamId != nil { + return *m.TargetSteamId + } + return 0 +} + +func (m *CMsgUseItem) GetGift_PotentialTargets() []uint32 { + if m != nil { + return m.Gift_PotentialTargets + } + return nil +} + +func (m *CMsgUseItem) GetDuel_ClassLock() uint32 { + if m != nil && m.Duel_ClassLock != nil { + return *m.Duel_ClassLock + } + return 0 +} + +func (m *CMsgUseItem) GetInitiatorSteamId() uint64 { + if m != nil && m.InitiatorSteamId != nil { + return *m.InitiatorSteamId + } + return 0 +} + +func (m *CMsgUseItem) GetItempack_AckImmediately() bool { + if m != nil && m.Itempack_AckImmediately != nil { + return *m.Itempack_AckImmediately + } + return false +} + +type CMsgServerUseItem struct { + InitiatorAccountId *uint32 `protobuf:"varint,1,opt,name=initiator_account_id" json:"initiator_account_id,omitempty"` + UseItemMsg *CMsgUseItem `protobuf:"bytes,2,opt,name=use_item_msg" json:"use_item_msg,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgServerUseItem) Reset() { *m = CMsgServerUseItem{} } +func (m *CMsgServerUseItem) String() string { return proto.CompactTextString(m) } +func (*CMsgServerUseItem) ProtoMessage() {} +func (*CMsgServerUseItem) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{32} } + +func (m *CMsgServerUseItem) GetInitiatorAccountId() uint32 { + if m != nil && m.InitiatorAccountId != nil { + return *m.InitiatorAccountId + } + return 0 +} + +func (m *CMsgServerUseItem) GetUseItemMsg() *CMsgUseItem { + if m != nil { + return m.UseItemMsg + } + return nil +} + +type CMsgGCPartnerBalanceRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPartnerBalanceRequest) Reset() { *m = CMsgGCPartnerBalanceRequest{} } +func (m *CMsgGCPartnerBalanceRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPartnerBalanceRequest) ProtoMessage() {} +func (*CMsgGCPartnerBalanceRequest) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{33} } + +type CMsgGCPartnerBalanceResponse struct { + Result *EGCPartnerRequestResponse `protobuf:"varint,1,opt,name=result,enum=EGCPartnerRequestResponse,def=1" json:"result,omitempty"` + Balance *uint32 `protobuf:"varint,2,opt,name=balance" json:"balance,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPartnerBalanceResponse) Reset() { *m = CMsgGCPartnerBalanceResponse{} } +func (m *CMsgGCPartnerBalanceResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPartnerBalanceResponse) ProtoMessage() {} +func (*CMsgGCPartnerBalanceResponse) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{34} } + +const Default_CMsgGCPartnerBalanceResponse_Result EGCPartnerRequestResponse = EGCPartnerRequestResponse_k_EPartnerRequestOK + +func (m *CMsgGCPartnerBalanceResponse) GetResult() EGCPartnerRequestResponse { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgGCPartnerBalanceResponse_Result +} + +func (m *CMsgGCPartnerBalanceResponse) GetBalance() uint32 { + if m != nil && m.Balance != nil { + return *m.Balance + } + return 0 +} + +type CGCStoreRechargeRedirect_LineItem struct { + ItemDefId *uint32 `protobuf:"varint,1,opt,name=item_def_id" json:"item_def_id,omitempty"` + Quantity *uint32 `protobuf:"varint,2,opt,name=quantity" json:"quantity,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCStoreRechargeRedirect_LineItem) Reset() { *m = CGCStoreRechargeRedirect_LineItem{} } +func (m *CGCStoreRechargeRedirect_LineItem) String() string { return proto.CompactTextString(m) } +func (*CGCStoreRechargeRedirect_LineItem) ProtoMessage() {} +func (*CGCStoreRechargeRedirect_LineItem) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{35} +} + +func (m *CGCStoreRechargeRedirect_LineItem) GetItemDefId() uint32 { + if m != nil && m.ItemDefId != nil { + return *m.ItemDefId + } + return 0 +} + +func (m *CGCStoreRechargeRedirect_LineItem) GetQuantity() uint32 { + if m != nil && m.Quantity != nil { + return *m.Quantity + } + return 0 +} + +type CMsgGCPartnerRechargeRedirectURLRequest struct { + LineItems []*CGCStoreRechargeRedirect_LineItem `protobuf:"bytes,1,rep,name=line_items" json:"line_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPartnerRechargeRedirectURLRequest) Reset() { + *m = CMsgGCPartnerRechargeRedirectURLRequest{} +} +func (m *CMsgGCPartnerRechargeRedirectURLRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPartnerRechargeRedirectURLRequest) ProtoMessage() {} +func (*CMsgGCPartnerRechargeRedirectURLRequest) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{36} +} + +func (m *CMsgGCPartnerRechargeRedirectURLRequest) GetLineItems() []*CGCStoreRechargeRedirect_LineItem { + if m != nil { + return m.LineItems + } + return nil +} + +type CMsgGCPartnerRechargeRedirectURLResponse struct { + Result *EGCPartnerRequestResponse `protobuf:"varint,1,opt,name=result,enum=EGCPartnerRequestResponse,def=1" json:"result,omitempty"` + Url *string `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCPartnerRechargeRedirectURLResponse) Reset() { + *m = CMsgGCPartnerRechargeRedirectURLResponse{} +} +func (m *CMsgGCPartnerRechargeRedirectURLResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCPartnerRechargeRedirectURLResponse) ProtoMessage() {} +func (*CMsgGCPartnerRechargeRedirectURLResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{37} +} + +const Default_CMsgGCPartnerRechargeRedirectURLResponse_Result EGCPartnerRequestResponse = EGCPartnerRequestResponse_k_EPartnerRequestOK + +func (m *CMsgGCPartnerRechargeRedirectURLResponse) GetResult() EGCPartnerRequestResponse { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgGCPartnerRechargeRedirectURLResponse_Result +} + +func (m *CMsgGCPartnerRechargeRedirectURLResponse) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +type CMsgGCEconSQLWorkItemEmbeddedRollbackData struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + DeletedItemId *uint64 `protobuf:"varint,2,opt,name=deleted_item_id" json:"deleted_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCEconSQLWorkItemEmbeddedRollbackData) Reset() { + *m = CMsgGCEconSQLWorkItemEmbeddedRollbackData{} +} +func (m *CMsgGCEconSQLWorkItemEmbeddedRollbackData) String() string { return proto.CompactTextString(m) } +func (*CMsgGCEconSQLWorkItemEmbeddedRollbackData) ProtoMessage() {} +func (*CMsgGCEconSQLWorkItemEmbeddedRollbackData) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{38} +} + +func (m *CMsgGCEconSQLWorkItemEmbeddedRollbackData) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCEconSQLWorkItemEmbeddedRollbackData) GetDeletedItemId() uint64 { + if m != nil && m.DeletedItemId != nil { + return *m.DeletedItemId + } + return 0 +} + +type CMsgCraftStatue struct { + Heroid *uint32 `protobuf:"varint,1,opt,name=heroid" json:"heroid,omitempty"` + Sequencename *string `protobuf:"bytes,2,opt,name=sequencename" json:"sequencename,omitempty"` + Cycle *float32 `protobuf:"fixed32,3,opt,name=cycle" json:"cycle,omitempty"` + Description *string `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"` + PedestalItemdef *uint32 `protobuf:"varint,5,opt,name=pedestal_itemdef" json:"pedestal_itemdef,omitempty"` + Toolid *uint64 `protobuf:"varint,6,opt,name=toolid" json:"toolid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCraftStatue) Reset() { *m = CMsgCraftStatue{} } +func (m *CMsgCraftStatue) String() string { return proto.CompactTextString(m) } +func (*CMsgCraftStatue) ProtoMessage() {} +func (*CMsgCraftStatue) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{39} } + +func (m *CMsgCraftStatue) GetHeroid() uint32 { + if m != nil && m.Heroid != nil { + return *m.Heroid + } + return 0 +} + +func (m *CMsgCraftStatue) GetSequencename() string { + if m != nil && m.Sequencename != nil { + return *m.Sequencename + } + return "" +} + +func (m *CMsgCraftStatue) GetCycle() float32 { + if m != nil && m.Cycle != nil { + return *m.Cycle + } + return 0 +} + +func (m *CMsgCraftStatue) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CMsgCraftStatue) GetPedestalItemdef() uint32 { + if m != nil && m.PedestalItemdef != nil { + return *m.PedestalItemdef + } + return 0 +} + +func (m *CMsgCraftStatue) GetToolid() uint64 { + if m != nil && m.Toolid != nil { + return *m.Toolid + } + return 0 +} + +type CMsgRedeemCode struct { + Code *string `protobuf:"bytes,1,opt,name=code" json:"code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRedeemCode) Reset() { *m = CMsgRedeemCode{} } +func (m *CMsgRedeemCode) String() string { return proto.CompactTextString(m) } +func (*CMsgRedeemCode) ProtoMessage() {} +func (*CMsgRedeemCode) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{40} } + +func (m *CMsgRedeemCode) GetCode() string { + if m != nil && m.Code != nil { + return *m.Code + } + return "" +} + +type CMsgRedeemCodeResponse struct { + Response *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgRedeemCodeResponse) Reset() { *m = CMsgRedeemCodeResponse{} } +func (m *CMsgRedeemCodeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgRedeemCodeResponse) ProtoMessage() {} +func (*CMsgRedeemCodeResponse) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{41} } + +func (m *CMsgRedeemCodeResponse) GetResponse() uint32 { + if m != nil && m.Response != nil { + return *m.Response + } + return 0 +} + +func (m *CMsgRedeemCodeResponse) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgDevNewItemRequest struct { + ItemDefName *string `protobuf:"bytes,3,opt,name=item_def_name" json:"item_def_name,omitempty"` + LootListName *string `protobuf:"bytes,4,opt,name=loot_list_name" json:"loot_list_name,omitempty"` + AttrDefName []string `protobuf:"bytes,5,rep,name=attr_def_name" json:"attr_def_name,omitempty"` + AttrValue []string `protobuf:"bytes,6,rep,name=attr_value" json:"attr_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDevNewItemRequest) Reset() { *m = CMsgDevNewItemRequest{} } +func (m *CMsgDevNewItemRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgDevNewItemRequest) ProtoMessage() {} +func (*CMsgDevNewItemRequest) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{42} } + +func (m *CMsgDevNewItemRequest) GetItemDefName() string { + if m != nil && m.ItemDefName != nil { + return *m.ItemDefName + } + return "" +} + +func (m *CMsgDevNewItemRequest) GetLootListName() string { + if m != nil && m.LootListName != nil { + return *m.LootListName + } + return "" +} + +func (m *CMsgDevNewItemRequest) GetAttrDefName() []string { + if m != nil { + return m.AttrDefName + } + return nil +} + +func (m *CMsgDevNewItemRequest) GetAttrValue() []string { + if m != nil { + return m.AttrValue + } + return nil +} + +type CMsgDevNewItemRequestResponse struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDevNewItemRequestResponse) Reset() { *m = CMsgDevNewItemRequestResponse{} } +func (m *CMsgDevNewItemRequestResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDevNewItemRequestResponse) ProtoMessage() {} +func (*CMsgDevNewItemRequestResponse) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{43} } + +func (m *CMsgDevNewItemRequestResponse) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +type CMsgGCAddGiftItem struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCAddGiftItem) Reset() { *m = CMsgGCAddGiftItem{} } +func (m *CMsgGCAddGiftItem) String() string { return proto.CompactTextString(m) } +func (*CMsgGCAddGiftItem) ProtoMessage() {} +func (*CMsgGCAddGiftItem) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{44} } + +func (m *CMsgGCAddGiftItem) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgGCAddGiftItem) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgClientToGCWrapAndDeliverGift struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + GiveToAccountId *uint32 `protobuf:"varint,2,opt,name=give_to_account_id" json:"give_to_account_id,omitempty"` + GiftMessage *string `protobuf:"bytes,3,opt,name=gift_message" json:"gift_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCWrapAndDeliverGift) Reset() { *m = CMsgClientToGCWrapAndDeliverGift{} } +func (m *CMsgClientToGCWrapAndDeliverGift) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCWrapAndDeliverGift) ProtoMessage() {} +func (*CMsgClientToGCWrapAndDeliverGift) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{45} +} + +func (m *CMsgClientToGCWrapAndDeliverGift) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgClientToGCWrapAndDeliverGift) GetGiveToAccountId() uint32 { + if m != nil && m.GiveToAccountId != nil { + return *m.GiveToAccountId + } + return 0 +} + +func (m *CMsgClientToGCWrapAndDeliverGift) GetGiftMessage() string { + if m != nil && m.GiftMessage != nil { + return *m.GiftMessage + } + return "" +} + +type CMsgClientToGCWrapAndDeliverGiftResponse struct { + Response *EGCMsgResponse `protobuf:"varint,1,opt,name=response,enum=EGCMsgResponse,def=0" json:"response,omitempty"` + GiftingChargeUses *uint32 `protobuf:"varint,2,opt,name=gifting_charge_uses" json:"gifting_charge_uses,omitempty"` + GiftingChargeMax *int32 `protobuf:"varint,3,opt,name=gifting_charge_max" json:"gifting_charge_max,omitempty"` + GiftingUses *uint32 `protobuf:"varint,4,opt,name=gifting_uses" json:"gifting_uses,omitempty"` + GiftingMax *int32 `protobuf:"varint,5,opt,name=gifting_max" json:"gifting_max,omitempty"` + GiftingWindowHours *uint32 `protobuf:"varint,6,opt,name=gifting_window_hours" json:"gifting_window_hours,omitempty"` + TradeRestriction *EGCMsgInitiateTradeResponse `protobuf:"varint,7,opt,name=trade_restriction,enum=EGCMsgInitiateTradeResponse,def=0" json:"trade_restriction,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) Reset() { + *m = CMsgClientToGCWrapAndDeliverGiftResponse{} +} +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCWrapAndDeliverGiftResponse) ProtoMessage() {} +func (*CMsgClientToGCWrapAndDeliverGiftResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{46} +} + +const Default_CMsgClientToGCWrapAndDeliverGiftResponse_Response EGCMsgResponse = EGCMsgResponse_k_EGCMsgResponseOK +const Default_CMsgClientToGCWrapAndDeliverGiftResponse_TradeRestriction EGCMsgInitiateTradeResponse = EGCMsgInitiateTradeResponse_k_EGCMsgInitiateTradeResponse_Accepted + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) GetResponse() EGCMsgResponse { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgClientToGCWrapAndDeliverGiftResponse_Response +} + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) GetGiftingChargeUses() uint32 { + if m != nil && m.GiftingChargeUses != nil { + return *m.GiftingChargeUses + } + return 0 +} + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) GetGiftingChargeMax() int32 { + if m != nil && m.GiftingChargeMax != nil { + return *m.GiftingChargeMax + } + return 0 +} + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) GetGiftingUses() uint32 { + if m != nil && m.GiftingUses != nil { + return *m.GiftingUses + } + return 0 +} + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) GetGiftingMax() int32 { + if m != nil && m.GiftingMax != nil { + return *m.GiftingMax + } + return 0 +} + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) GetGiftingWindowHours() uint32 { + if m != nil && m.GiftingWindowHours != nil { + return *m.GiftingWindowHours + } + return 0 +} + +func (m *CMsgClientToGCWrapAndDeliverGiftResponse) GetTradeRestriction() EGCMsgInitiateTradeResponse { + if m != nil && m.TradeRestriction != nil { + return *m.TradeRestriction + } + return Default_CMsgClientToGCWrapAndDeliverGiftResponse_TradeRestriction +} + +type CMsgClientToGCUnwrapGift struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnwrapGift) Reset() { *m = CMsgClientToGCUnwrapGift{} } +func (m *CMsgClientToGCUnwrapGift) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnwrapGift) ProtoMessage() {} +func (*CMsgClientToGCUnwrapGift) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{47} } + +func (m *CMsgClientToGCUnwrapGift) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgClientToGCUnpackBundle struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnpackBundle) Reset() { *m = CMsgClientToGCUnpackBundle{} } +func (m *CMsgClientToGCUnpackBundle) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnpackBundle) ProtoMessage() {} +func (*CMsgClientToGCUnpackBundle) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{48} } + +func (m *CMsgClientToGCUnpackBundle) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgClientToGCUnpackBundleResponse struct { + UnpackedItemIds []uint64 `protobuf:"varint,1,rep,name=unpacked_item_ids" json:"unpacked_item_ids,omitempty"` + Response *CMsgClientToGCUnpackBundleResponse_EUnpackBundle `protobuf:"varint,2,opt,name=response,enum=CMsgClientToGCUnpackBundleResponse_EUnpackBundle,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnpackBundleResponse) Reset() { *m = CMsgClientToGCUnpackBundleResponse{} } +func (m *CMsgClientToGCUnpackBundleResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnpackBundleResponse) ProtoMessage() {} +func (*CMsgClientToGCUnpackBundleResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{49} +} + +const Default_CMsgClientToGCUnpackBundleResponse_Response CMsgClientToGCUnpackBundleResponse_EUnpackBundle = CMsgClientToGCUnpackBundleResponse_k_UnpackBundle_Succeeded + +func (m *CMsgClientToGCUnpackBundleResponse) GetUnpackedItemIds() []uint64 { + if m != nil { + return m.UnpackedItemIds + } + return nil +} + +func (m *CMsgClientToGCUnpackBundleResponse) GetResponse() CMsgClientToGCUnpackBundleResponse_EUnpackBundle { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgClientToGCUnpackBundleResponse_Response +} + +type CMsgGCToClientStoreTransactionCompleted struct { + TxnId *uint64 `protobuf:"varint,1,opt,name=txn_id" json:"txn_id,omitempty"` + ItemIds []uint64 `protobuf:"varint,2,rep,name=item_ids" json:"item_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToClientStoreTransactionCompleted) Reset() { + *m = CMsgGCToClientStoreTransactionCompleted{} +} +func (m *CMsgGCToClientStoreTransactionCompleted) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToClientStoreTransactionCompleted) ProtoMessage() {} +func (*CMsgGCToClientStoreTransactionCompleted) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{50} +} + +func (m *CMsgGCToClientStoreTransactionCompleted) GetTxnId() uint64 { + if m != nil && m.TxnId != nil { + return *m.TxnId + } + return 0 +} + +func (m *CMsgGCToClientStoreTransactionCompleted) GetItemIds() []uint64 { + if m != nil { + return m.ItemIds + } + return nil +} + +type CMsgClientToGCEquipItems struct { + Equips []*CMsgAdjustItemEquippedState `protobuf:"bytes,1,rep,name=equips" json:"equips,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCEquipItems) Reset() { *m = CMsgClientToGCEquipItems{} } +func (m *CMsgClientToGCEquipItems) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCEquipItems) ProtoMessage() {} +func (*CMsgClientToGCEquipItems) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{51} } + +func (m *CMsgClientToGCEquipItems) GetEquips() []*CMsgAdjustItemEquippedState { + if m != nil { + return m.Equips + } + return nil +} + +type CMsgClientToGCEquipItemsResponse struct { + SoCacheVersionId *uint64 `protobuf:"fixed64,1,opt,name=so_cache_version_id" json:"so_cache_version_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCEquipItemsResponse) Reset() { *m = CMsgClientToGCEquipItemsResponse{} } +func (m *CMsgClientToGCEquipItemsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCEquipItemsResponse) ProtoMessage() {} +func (*CMsgClientToGCEquipItemsResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{52} +} + +func (m *CMsgClientToGCEquipItemsResponse) GetSoCacheVersionId() uint64 { + if m != nil && m.SoCacheVersionId != nil { + return *m.SoCacheVersionId + } + return 0 +} + +type CMsgClientToGCSetItemStyle struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + StyleIndex *uint32 `protobuf:"varint,2,opt,name=style_index" json:"style_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSetItemStyle) Reset() { *m = CMsgClientToGCSetItemStyle{} } +func (m *CMsgClientToGCSetItemStyle) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCSetItemStyle) ProtoMessage() {} +func (*CMsgClientToGCSetItemStyle) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{53} } + +func (m *CMsgClientToGCSetItemStyle) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgClientToGCSetItemStyle) GetStyleIndex() uint32 { + if m != nil && m.StyleIndex != nil { + return *m.StyleIndex + } + return 0 +} + +type CMsgClientToGCSetItemStyleResponse struct { + Response *CMsgClientToGCSetItemStyleResponse_ESetStyle `protobuf:"varint,1,opt,name=response,enum=CMsgClientToGCSetItemStyleResponse_ESetStyle,def=0" json:"response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSetItemStyleResponse) Reset() { *m = CMsgClientToGCSetItemStyleResponse{} } +func (m *CMsgClientToGCSetItemStyleResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCSetItemStyleResponse) ProtoMessage() {} +func (*CMsgClientToGCSetItemStyleResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{54} +} + +const Default_CMsgClientToGCSetItemStyleResponse_Response CMsgClientToGCSetItemStyleResponse_ESetStyle = CMsgClientToGCSetItemStyleResponse_k_SetStyle_Succeeded + +func (m *CMsgClientToGCSetItemStyleResponse) GetResponse() CMsgClientToGCSetItemStyleResponse_ESetStyle { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgClientToGCSetItemStyleResponse_Response +} + +type CMsgClientToGCUnlockItemStyle struct { + ItemToUnlock *uint64 `protobuf:"varint,1,opt,name=item_to_unlock" json:"item_to_unlock,omitempty"` + StyleIndex *uint32 `protobuf:"varint,2,opt,name=style_index" json:"style_index,omitempty"` + ConsumableItemIds []uint64 `protobuf:"varint,3,rep,name=consumable_item_ids" json:"consumable_item_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnlockItemStyle) Reset() { *m = CMsgClientToGCUnlockItemStyle{} } +func (m *CMsgClientToGCUnlockItemStyle) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnlockItemStyle) ProtoMessage() {} +func (*CMsgClientToGCUnlockItemStyle) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{55} } + +func (m *CMsgClientToGCUnlockItemStyle) GetItemToUnlock() uint64 { + if m != nil && m.ItemToUnlock != nil { + return *m.ItemToUnlock + } + return 0 +} + +func (m *CMsgClientToGCUnlockItemStyle) GetStyleIndex() uint32 { + if m != nil && m.StyleIndex != nil { + return *m.StyleIndex + } + return 0 +} + +func (m *CMsgClientToGCUnlockItemStyle) GetConsumableItemIds() []uint64 { + if m != nil { + return m.ConsumableItemIds + } + return nil +} + +type CMsgClientToGCUnlockItemStyleResponse struct { + Response *CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle `protobuf:"varint,1,opt,name=response,enum=CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle,def=0" json:"response,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + StyleIndex *uint32 `protobuf:"varint,3,opt,name=style_index" json:"style_index,omitempty"` + StylePrereq *uint32 `protobuf:"varint,4,opt,name=style_prereq" json:"style_prereq,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnlockItemStyleResponse) Reset() { *m = CMsgClientToGCUnlockItemStyleResponse{} } +func (m *CMsgClientToGCUnlockItemStyleResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnlockItemStyleResponse) ProtoMessage() {} +func (*CMsgClientToGCUnlockItemStyleResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{56} +} + +const Default_CMsgClientToGCUnlockItemStyleResponse_Response CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle = CMsgClientToGCUnlockItemStyleResponse_k_UnlockStyle_Succeeded + +func (m *CMsgClientToGCUnlockItemStyleResponse) GetResponse() CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgClientToGCUnlockItemStyleResponse_Response +} + +func (m *CMsgClientToGCUnlockItemStyleResponse) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgClientToGCUnlockItemStyleResponse) GetStyleIndex() uint32 { + if m != nil && m.StyleIndex != nil { + return *m.StyleIndex + } + return 0 +} + +func (m *CMsgClientToGCUnlockItemStyleResponse) GetStylePrereq() uint32 { + if m != nil && m.StylePrereq != nil { + return *m.StylePrereq + } + return 0 +} + +type CMsgClientToGCSetItemInventoryCategory struct { + ItemIds []uint64 `protobuf:"varint,1,rep,name=item_ids" json:"item_ids,omitempty"` + SetToValue *uint32 `protobuf:"varint,2,opt,name=set_to_value" json:"set_to_value,omitempty"` + RemoveCategories *uint32 `protobuf:"varint,3,opt,name=remove_categories" json:"remove_categories,omitempty"` + AddCategories *uint32 `protobuf:"varint,4,opt,name=add_categories" json:"add_categories,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCSetItemInventoryCategory) Reset() { + *m = CMsgClientToGCSetItemInventoryCategory{} +} +func (m *CMsgClientToGCSetItemInventoryCategory) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCSetItemInventoryCategory) ProtoMessage() {} +func (*CMsgClientToGCSetItemInventoryCategory) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{57} +} + +func (m *CMsgClientToGCSetItemInventoryCategory) GetItemIds() []uint64 { + if m != nil { + return m.ItemIds + } + return nil +} + +func (m *CMsgClientToGCSetItemInventoryCategory) GetSetToValue() uint32 { + if m != nil && m.SetToValue != nil { + return *m.SetToValue + } + return 0 +} + +func (m *CMsgClientToGCSetItemInventoryCategory) GetRemoveCategories() uint32 { + if m != nil && m.RemoveCategories != nil { + return *m.RemoveCategories + } + return 0 +} + +func (m *CMsgClientToGCSetItemInventoryCategory) GetAddCategories() uint32 { + if m != nil && m.AddCategories != nil { + return *m.AddCategories + } + return 0 +} + +type CMsgClientToGCUnlockCrate struct { + CrateItemId *uint64 `protobuf:"varint,1,opt,name=crate_item_id" json:"crate_item_id,omitempty"` + KeyItemId *uint64 `protobuf:"varint,2,opt,name=key_item_id" json:"key_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnlockCrate) Reset() { *m = CMsgClientToGCUnlockCrate{} } +func (m *CMsgClientToGCUnlockCrate) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnlockCrate) ProtoMessage() {} +func (*CMsgClientToGCUnlockCrate) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{58} } + +func (m *CMsgClientToGCUnlockCrate) GetCrateItemId() uint64 { + if m != nil && m.CrateItemId != nil { + return *m.CrateItemId + } + return 0 +} + +func (m *CMsgClientToGCUnlockCrate) GetKeyItemId() uint64 { + if m != nil && m.KeyItemId != nil { + return *m.KeyItemId + } + return 0 +} + +type CMsgClientToGCUnlockCrateResponse struct { + Result *EGCMsgResponse `protobuf:"varint,1,opt,name=result,enum=EGCMsgResponse,def=0" json:"result,omitempty"` + GrantedItems []*CMsgClientToGCUnlockCrateResponse_Item `protobuf:"bytes,2,rep,name=granted_items" json:"granted_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnlockCrateResponse) Reset() { *m = CMsgClientToGCUnlockCrateResponse{} } +func (m *CMsgClientToGCUnlockCrateResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnlockCrateResponse) ProtoMessage() {} +func (*CMsgClientToGCUnlockCrateResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{59} +} + +const Default_CMsgClientToGCUnlockCrateResponse_Result EGCMsgResponse = EGCMsgResponse_k_EGCMsgResponseOK + +func (m *CMsgClientToGCUnlockCrateResponse) GetResult() EGCMsgResponse { + if m != nil && m.Result != nil { + return *m.Result + } + return Default_CMsgClientToGCUnlockCrateResponse_Result +} + +func (m *CMsgClientToGCUnlockCrateResponse) GetGrantedItems() []*CMsgClientToGCUnlockCrateResponse_Item { + if m != nil { + return m.GrantedItems + } + return nil +} + +type CMsgClientToGCUnlockCrateResponse_Item struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + DefIndex *uint32 `protobuf:"varint,2,opt,name=def_index" json:"def_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCUnlockCrateResponse_Item) Reset() { + *m = CMsgClientToGCUnlockCrateResponse_Item{} +} +func (m *CMsgClientToGCUnlockCrateResponse_Item) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCUnlockCrateResponse_Item) ProtoMessage() {} +func (*CMsgClientToGCUnlockCrateResponse_Item) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{59, 0} +} + +func (m *CMsgClientToGCUnlockCrateResponse_Item) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgClientToGCUnlockCrateResponse_Item) GetDefIndex() uint32 { + if m != nil && m.DefIndex != nil { + return *m.DefIndex + } + return 0 +} + +type CMsgClientToGCRemoveItemAttribute struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCRemoveItemAttribute) Reset() { *m = CMsgClientToGCRemoveItemAttribute{} } +func (m *CMsgClientToGCRemoveItemAttribute) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCRemoveItemAttribute) ProtoMessage() {} +func (*CMsgClientToGCRemoveItemAttribute) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{60} +} + +func (m *CMsgClientToGCRemoveItemAttribute) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgClientToGCRemoveItemAttributeResponse struct { + Response *CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute `protobuf:"varint,1,opt,name=response,enum=CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute,def=0" json:"response,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCRemoveItemAttributeResponse) Reset() { + *m = CMsgClientToGCRemoveItemAttributeResponse{} +} +func (m *CMsgClientToGCRemoveItemAttributeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCRemoveItemAttributeResponse) ProtoMessage() {} +func (*CMsgClientToGCRemoveItemAttributeResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{61} +} + +const Default_CMsgClientToGCRemoveItemAttributeResponse_Response CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute = CMsgClientToGCRemoveItemAttributeResponse_k_RemoveItemAttribute_Succeeded + +func (m *CMsgClientToGCRemoveItemAttributeResponse) GetResponse() CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgClientToGCRemoveItemAttributeResponse_Response +} + +func (m *CMsgClientToGCRemoveItemAttributeResponse) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgClientToGCNameItem struct { + SubjectItemId *uint64 `protobuf:"varint,1,opt,name=subject_item_id" json:"subject_item_id,omitempty"` + ToolItemId *uint64 `protobuf:"varint,2,opt,name=tool_item_id" json:"tool_item_id,omitempty"` + Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCNameItem) Reset() { *m = CMsgClientToGCNameItem{} } +func (m *CMsgClientToGCNameItem) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCNameItem) ProtoMessage() {} +func (*CMsgClientToGCNameItem) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{62} } + +func (m *CMsgClientToGCNameItem) GetSubjectItemId() uint64 { + if m != nil && m.SubjectItemId != nil { + return *m.SubjectItemId + } + return 0 +} + +func (m *CMsgClientToGCNameItem) GetToolItemId() uint64 { + if m != nil && m.ToolItemId != nil { + return *m.ToolItemId + } + return 0 +} + +func (m *CMsgClientToGCNameItem) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type CMsgClientToGCNameItemResponse struct { + Response *CMsgClientToGCNameItemResponse_ENameItem `protobuf:"varint,1,opt,name=response,enum=CMsgClientToGCNameItemResponse_ENameItem,def=0" json:"response,omitempty"` + ItemId *uint64 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCNameItemResponse) Reset() { *m = CMsgClientToGCNameItemResponse{} } +func (m *CMsgClientToGCNameItemResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCNameItemResponse) ProtoMessage() {} +func (*CMsgClientToGCNameItemResponse) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{63} } + +const Default_CMsgClientToGCNameItemResponse_Response CMsgClientToGCNameItemResponse_ENameItem = CMsgClientToGCNameItemResponse_k_NameItem_Succeeded + +func (m *CMsgClientToGCNameItemResponse) GetResponse() CMsgClientToGCNameItemResponse_ENameItem { + if m != nil && m.Response != nil { + return *m.Response + } + return Default_CMsgClientToGCNameItemResponse_Response +} + +func (m *CMsgClientToGCNameItemResponse) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +type CMsgGCSetItemPosition struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + NewPosition *uint32 `protobuf:"varint,2,opt,name=new_position" json:"new_position,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCSetItemPosition) Reset() { *m = CMsgGCSetItemPosition{} } +func (m *CMsgGCSetItemPosition) String() string { return proto.CompactTextString(m) } +func (*CMsgGCSetItemPosition) ProtoMessage() {} +func (*CMsgGCSetItemPosition) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{64} } + +func (m *CMsgGCSetItemPosition) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CMsgGCSetItemPosition) GetNewPosition() uint32 { + if m != nil && m.NewPosition != nil { + return *m.NewPosition + } + return 0 +} + +type CAttribute_ItemDynamicRecipeComponent struct { + ItemDef *uint32 `protobuf:"varint,1,opt,name=item_def" json:"item_def,omitempty"` + ItemQuality *uint32 `protobuf:"varint,2,opt,name=item_quality" json:"item_quality,omitempty"` + ItemFlags *uint32 `protobuf:"varint,3,opt,name=item_flags" json:"item_flags,omitempty"` + AttributesString *string `protobuf:"bytes,4,opt,name=attributes_string" json:"attributes_string,omitempty"` + ItemCount *uint32 `protobuf:"varint,5,opt,name=item_count" json:"item_count,omitempty"` + ItemsFulfilled *uint32 `protobuf:"varint,6,opt,name=items_fulfilled" json:"items_fulfilled,omitempty"` + ItemRarity *uint32 `protobuf:"varint,7,opt,name=item_rarity" json:"item_rarity,omitempty"` + Lootlist *string `protobuf:"bytes,8,opt,name=lootlist" json:"lootlist,omitempty"` + FulfilledItemId *uint64 `protobuf:"varint,9,opt,name=fulfilled_item_id" json:"fulfilled_item_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CAttribute_ItemDynamicRecipeComponent) Reset() { *m = CAttribute_ItemDynamicRecipeComponent{} } +func (m *CAttribute_ItemDynamicRecipeComponent) String() string { return proto.CompactTextString(m) } +func (*CAttribute_ItemDynamicRecipeComponent) ProtoMessage() {} +func (*CAttribute_ItemDynamicRecipeComponent) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{65} +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetItemDef() uint32 { + if m != nil && m.ItemDef != nil { + return *m.ItemDef + } + return 0 +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetItemQuality() uint32 { + if m != nil && m.ItemQuality != nil { + return *m.ItemQuality + } + return 0 +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetItemFlags() uint32 { + if m != nil && m.ItemFlags != nil { + return *m.ItemFlags + } + return 0 +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetAttributesString() string { + if m != nil && m.AttributesString != nil { + return *m.AttributesString + } + return "" +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetItemCount() uint32 { + if m != nil && m.ItemCount != nil { + return *m.ItemCount + } + return 0 +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetItemsFulfilled() uint32 { + if m != nil && m.ItemsFulfilled != nil { + return *m.ItemsFulfilled + } + return 0 +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetItemRarity() uint32 { + if m != nil && m.ItemRarity != nil { + return *m.ItemRarity + } + return 0 +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetLootlist() string { + if m != nil && m.Lootlist != nil { + return *m.Lootlist + } + return "" +} + +func (m *CAttribute_ItemDynamicRecipeComponent) GetFulfilledItemId() uint64 { + if m != nil && m.FulfilledItemId != nil { + return *m.FulfilledItemId + } + return 0 +} + +type CProtoItemSocket struct { + ItemId *uint64 `protobuf:"varint,1,opt,name=item_id" json:"item_id,omitempty"` + AttrDefIndex *uint32 `protobuf:"varint,2,opt,name=attr_def_index" json:"attr_def_index,omitempty"` + RequiredType *uint32 `protobuf:"varint,3,opt,name=required_type" json:"required_type,omitempty"` + RequiredHero *string `protobuf:"bytes,4,opt,name=required_hero" json:"required_hero,omitempty"` + GemDefIndex *uint32 `protobuf:"varint,5,opt,name=gem_def_index" json:"gem_def_index,omitempty"` + NotTradable *bool `protobuf:"varint,6,opt,name=not_tradable" json:"not_tradable,omitempty"` + RequiredItemSlot *string `protobuf:"bytes,7,opt,name=required_item_slot" json:"required_item_slot,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket) Reset() { *m = CProtoItemSocket{} } +func (m *CProtoItemSocket) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket) ProtoMessage() {} +func (*CProtoItemSocket) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{66} } + +func (m *CProtoItemSocket) GetItemId() uint64 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CProtoItemSocket) GetAttrDefIndex() uint32 { + if m != nil && m.AttrDefIndex != nil { + return *m.AttrDefIndex + } + return 0 +} + +func (m *CProtoItemSocket) GetRequiredType() uint32 { + if m != nil && m.RequiredType != nil { + return *m.RequiredType + } + return 0 +} + +func (m *CProtoItemSocket) GetRequiredHero() string { + if m != nil && m.RequiredHero != nil { + return *m.RequiredHero + } + return "" +} + +func (m *CProtoItemSocket) GetGemDefIndex() uint32 { + if m != nil && m.GemDefIndex != nil { + return *m.GemDefIndex + } + return 0 +} + +func (m *CProtoItemSocket) GetNotTradable() bool { + if m != nil && m.NotTradable != nil { + return *m.NotTradable + } + return false +} + +func (m *CProtoItemSocket) GetRequiredItemSlot() string { + if m != nil && m.RequiredItemSlot != nil { + return *m.RequiredItemSlot + } + return "" +} + +type CProtoItemSocket_Empty struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_Empty) Reset() { *m = CProtoItemSocket_Empty{} } +func (m *CProtoItemSocket_Empty) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_Empty) ProtoMessage() {} +func (*CProtoItemSocket_Empty) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{67} } + +func (m *CProtoItemSocket_Empty) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +type CProtoItemSocket_Effect struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + Effect *uint32 `protobuf:"varint,2,opt,name=effect" json:"effect,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_Effect) Reset() { *m = CProtoItemSocket_Effect{} } +func (m *CProtoItemSocket_Effect) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_Effect) ProtoMessage() {} +func (*CProtoItemSocket_Effect) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{68} } + +func (m *CProtoItemSocket_Effect) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +func (m *CProtoItemSocket_Effect) GetEffect() uint32 { + if m != nil && m.Effect != nil { + return *m.Effect + } + return 0 +} + +type CProtoItemSocket_Color struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + Red *uint32 `protobuf:"varint,2,opt,name=red" json:"red,omitempty"` + Green *uint32 `protobuf:"varint,3,opt,name=green" json:"green,omitempty"` + Blue *uint32 `protobuf:"varint,4,opt,name=blue" json:"blue,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_Color) Reset() { *m = CProtoItemSocket_Color{} } +func (m *CProtoItemSocket_Color) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_Color) ProtoMessage() {} +func (*CProtoItemSocket_Color) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{69} } + +func (m *CProtoItemSocket_Color) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +func (m *CProtoItemSocket_Color) GetRed() uint32 { + if m != nil && m.Red != nil { + return *m.Red + } + return 0 +} + +func (m *CProtoItemSocket_Color) GetGreen() uint32 { + if m != nil && m.Green != nil { + return *m.Green + } + return 0 +} + +func (m *CProtoItemSocket_Color) GetBlue() uint32 { + if m != nil && m.Blue != nil { + return *m.Blue + } + return 0 +} + +type CProtoItemSocket_Strange struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + StrangeType *uint32 `protobuf:"varint,2,opt,name=strange_type" json:"strange_type,omitempty"` + StrangeValue *uint32 `protobuf:"varint,3,opt,name=strange_value" json:"strange_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_Strange) Reset() { *m = CProtoItemSocket_Strange{} } +func (m *CProtoItemSocket_Strange) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_Strange) ProtoMessage() {} +func (*CProtoItemSocket_Strange) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{70} } + +func (m *CProtoItemSocket_Strange) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +func (m *CProtoItemSocket_Strange) GetStrangeType() uint32 { + if m != nil && m.StrangeType != nil { + return *m.StrangeType + } + return 0 +} + +func (m *CProtoItemSocket_Strange) GetStrangeValue() uint32 { + if m != nil && m.StrangeValue != nil { + return *m.StrangeValue + } + return 0 +} + +type CProtoItemSocket_Spectator struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + GamesViewed *uint32 `protobuf:"varint,2,opt,name=games_viewed" json:"games_viewed,omitempty"` + CorporationId *uint32 `protobuf:"varint,3,opt,name=corporation_id" json:"corporation_id,omitempty"` + LeagueId *uint32 `protobuf:"varint,4,opt,name=league_id" json:"league_id,omitempty"` + TeamId *uint32 `protobuf:"varint,5,opt,name=team_id" json:"team_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_Spectator) Reset() { *m = CProtoItemSocket_Spectator{} } +func (m *CProtoItemSocket_Spectator) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_Spectator) ProtoMessage() {} +func (*CProtoItemSocket_Spectator) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{71} } + +func (m *CProtoItemSocket_Spectator) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +func (m *CProtoItemSocket_Spectator) GetGamesViewed() uint32 { + if m != nil && m.GamesViewed != nil { + return *m.GamesViewed + } + return 0 +} + +func (m *CProtoItemSocket_Spectator) GetCorporationId() uint32 { + if m != nil && m.CorporationId != nil { + return *m.CorporationId + } + return 0 +} + +func (m *CProtoItemSocket_Spectator) GetLeagueId() uint32 { + if m != nil && m.LeagueId != nil { + return *m.LeagueId + } + return 0 +} + +func (m *CProtoItemSocket_Spectator) GetTeamId() uint32 { + if m != nil && m.TeamId != nil { + return *m.TeamId + } + return 0 +} + +type CProtoItemSocket_AssetModifier struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + AssetModifier *uint32 `protobuf:"varint,2,opt,name=asset_modifier" json:"asset_modifier,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_AssetModifier) Reset() { *m = CProtoItemSocket_AssetModifier{} } +func (m *CProtoItemSocket_AssetModifier) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_AssetModifier) ProtoMessage() {} +func (*CProtoItemSocket_AssetModifier) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{72} } + +func (m *CProtoItemSocket_AssetModifier) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +func (m *CProtoItemSocket_AssetModifier) GetAssetModifier() uint32 { + if m != nil && m.AssetModifier != nil { + return *m.AssetModifier + } + return 0 +} + +type CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + AssetModifier *uint32 `protobuf:"varint,2,opt,name=asset_modifier" json:"asset_modifier,omitempty"` + AnimModifier *uint32 `protobuf:"varint,3,opt,name=anim_modifier" json:"anim_modifier,omitempty"` + AbilityEffect *uint32 `protobuf:"varint,4,opt,name=ability_effect" json:"ability_effect,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) Reset() { + *m = CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY{} +} +func (m *CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) String() string { + return proto.CompactTextString(m) +} +func (*CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) ProtoMessage() {} +func (*CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{73} +} + +func (m *CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +func (m *CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) GetAssetModifier() uint32 { + if m != nil && m.AssetModifier != nil { + return *m.AssetModifier + } + return 0 +} + +func (m *CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) GetAnimModifier() uint32 { + if m != nil && m.AnimModifier != nil { + return *m.AnimModifier + } + return 0 +} + +func (m *CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY) GetAbilityEffect() uint32 { + if m != nil && m.AbilityEffect != nil { + return *m.AbilityEffect + } + return 0 +} + +type CProtoItemSocket_Autograph struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + Autograph *string `protobuf:"bytes,2,opt,name=autograph" json:"autograph,omitempty"` + AutographId *uint32 `protobuf:"varint,3,opt,name=autograph_id" json:"autograph_id,omitempty"` + AutographScore *uint32 `protobuf:"varint,4,opt,name=autograph_score" json:"autograph_score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_Autograph) Reset() { *m = CProtoItemSocket_Autograph{} } +func (m *CProtoItemSocket_Autograph) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_Autograph) ProtoMessage() {} +func (*CProtoItemSocket_Autograph) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{74} } + +func (m *CProtoItemSocket_Autograph) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +func (m *CProtoItemSocket_Autograph) GetAutograph() string { + if m != nil && m.Autograph != nil { + return *m.Autograph + } + return "" +} + +func (m *CProtoItemSocket_Autograph) GetAutographId() uint32 { + if m != nil && m.AutographId != nil { + return *m.AutographId + } + return 0 +} + +func (m *CProtoItemSocket_Autograph) GetAutographScore() uint32 { + if m != nil && m.AutographScore != nil { + return *m.AutographScore + } + return 0 +} + +type CProtoItemSocket_StaticVisuals struct { + Socket *CProtoItemSocket `protobuf:"bytes,1,opt,name=socket" json:"socket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CProtoItemSocket_StaticVisuals) Reset() { *m = CProtoItemSocket_StaticVisuals{} } +func (m *CProtoItemSocket_StaticVisuals) String() string { return proto.CompactTextString(m) } +func (*CProtoItemSocket_StaticVisuals) ProtoMessage() {} +func (*CProtoItemSocket_StaticVisuals) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{75} } + +func (m *CProtoItemSocket_StaticVisuals) GetSocket() *CProtoItemSocket { + if m != nil { + return m.Socket + } + return nil +} + +type CAttribute_String struct { + Value *string `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CAttribute_String) Reset() { *m = CAttribute_String{} } +func (m *CAttribute_String) String() string { return proto.CompactTextString(m) } +func (*CAttribute_String) ProtoMessage() {} +func (*CAttribute_String) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{76} } + +func (m *CAttribute_String) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CWorkshop_GetItemDailyRevenue_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + ItemId *uint32 `protobuf:"varint,2,opt,name=item_id" json:"item_id,omitempty"` + DateStart *uint32 `protobuf:"varint,3,opt,name=date_start" json:"date_start,omitempty"` + DateEnd *uint32 `protobuf:"varint,4,opt,name=date_end" json:"date_end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_GetItemDailyRevenue_Request) Reset() { *m = CWorkshop_GetItemDailyRevenue_Request{} } +func (m *CWorkshop_GetItemDailyRevenue_Request) String() string { return proto.CompactTextString(m) } +func (*CWorkshop_GetItemDailyRevenue_Request) ProtoMessage() {} +func (*CWorkshop_GetItemDailyRevenue_Request) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{77} +} + +func (m *CWorkshop_GetItemDailyRevenue_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CWorkshop_GetItemDailyRevenue_Request) GetItemId() uint32 { + if m != nil && m.ItemId != nil { + return *m.ItemId + } + return 0 +} + +func (m *CWorkshop_GetItemDailyRevenue_Request) GetDateStart() uint32 { + if m != nil && m.DateStart != nil { + return *m.DateStart + } + return 0 +} + +func (m *CWorkshop_GetItemDailyRevenue_Request) GetDateEnd() uint32 { + if m != nil && m.DateEnd != nil { + return *m.DateEnd + } + return 0 +} + +type CWorkshop_GetItemDailyRevenue_Response struct { + CountryRevenue []*CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue `protobuf:"bytes,1,rep,name=country_revenue" json:"country_revenue,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_GetItemDailyRevenue_Response) Reset() { + *m = CWorkshop_GetItemDailyRevenue_Response{} +} +func (m *CWorkshop_GetItemDailyRevenue_Response) String() string { return proto.CompactTextString(m) } +func (*CWorkshop_GetItemDailyRevenue_Response) ProtoMessage() {} +func (*CWorkshop_GetItemDailyRevenue_Response) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{78} +} + +func (m *CWorkshop_GetItemDailyRevenue_Response) GetCountryRevenue() []*CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue { + if m != nil { + return m.CountryRevenue + } + return nil +} + +type CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue struct { + CountryCode *string `protobuf:"bytes,1,opt,name=country_code" json:"country_code,omitempty"` + Date *uint32 `protobuf:"varint,2,opt,name=date" json:"date,omitempty"` + RevenueUsd *int64 `protobuf:"varint,3,opt,name=revenue_usd" json:"revenue_usd,omitempty"` + Units *int32 `protobuf:"varint,4,opt,name=units" json:"units,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) Reset() { + *m = CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue{} +} +func (m *CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) String() string { + return proto.CompactTextString(m) +} +func (*CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) ProtoMessage() {} +func (*CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{78, 0} +} + +func (m *CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) GetDate() uint32 { + if m != nil && m.Date != nil { + return *m.Date + } + return 0 +} + +func (m *CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) GetRevenueUsd() int64 { + if m != nil && m.RevenueUsd != nil { + return *m.RevenueUsd + } + return 0 +} + +func (m *CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue) GetUnits() int32 { + if m != nil && m.Units != nil { + return *m.Units + } + return 0 +} + +type CMsgGenericResult struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGenericResult) Reset() { *m = CMsgGenericResult{} } +func (m *CMsgGenericResult) String() string { return proto.CompactTextString(m) } +func (*CMsgGenericResult) ProtoMessage() {} +func (*CMsgGenericResult) Descriptor() ([]byte, []int) { return econ_fileDescriptor0, []int{79} } + +const Default_CMsgGenericResult_Eresult uint32 = 2 + +func (m *CMsgGenericResult) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgGenericResult_Eresult +} + +type CMsgSQLGCToGCGrantBackpackSlots struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + AddSlots *uint32 `protobuf:"varint,2,opt,name=add_slots" json:"add_slots,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSQLGCToGCGrantBackpackSlots) Reset() { *m = CMsgSQLGCToGCGrantBackpackSlots{} } +func (m *CMsgSQLGCToGCGrantBackpackSlots) String() string { return proto.CompactTextString(m) } +func (*CMsgSQLGCToGCGrantBackpackSlots) ProtoMessage() {} +func (*CMsgSQLGCToGCGrantBackpackSlots) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{80} +} + +func (m *CMsgSQLGCToGCGrantBackpackSlots) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgSQLGCToGCGrantBackpackSlots) GetAddSlots() uint32 { + if m != nil && m.AddSlots != nil { + return *m.AddSlots + } + return 0 +} + +type CMsgClientToGCLookupAccountName struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCLookupAccountName) Reset() { *m = CMsgClientToGCLookupAccountName{} } +func (m *CMsgClientToGCLookupAccountName) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCLookupAccountName) ProtoMessage() {} +func (*CMsgClientToGCLookupAccountName) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{81} +} + +func (m *CMsgClientToGCLookupAccountName) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgClientToGCLookupAccountNameResponse struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + AccountName *string `protobuf:"bytes,2,opt,name=account_name" json:"account_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientToGCLookupAccountNameResponse) Reset() { + *m = CMsgClientToGCLookupAccountNameResponse{} +} +func (m *CMsgClientToGCLookupAccountNameResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientToGCLookupAccountNameResponse) ProtoMessage() {} +func (*CMsgClientToGCLookupAccountNameResponse) Descriptor() ([]byte, []int) { + return econ_fileDescriptor0, []int{82} +} + +func (m *CMsgClientToGCLookupAccountNameResponse) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CMsgClientToGCLookupAccountNameResponse) GetAccountName() string { + if m != nil && m.AccountName != nil { + return *m.AccountName + } + return "" +} + +func init() { + proto.RegisterType((*CMsgApplyAutograph)(nil), "CMsgApplyAutograph") + proto.RegisterType((*CMsgAdjustItemEquippedState)(nil), "CMsgAdjustItemEquippedState") + proto.RegisterType((*CMsgEconPlayerStrangeCountAdjustment)(nil), "CMsgEconPlayerStrangeCountAdjustment") + proto.RegisterType((*CMsgEconPlayerStrangeCountAdjustment_CStrangeCountAdjustment)(nil), "CMsgEconPlayerStrangeCountAdjustment.CStrangeCountAdjustment") + proto.RegisterType((*CMsgRequestItemPurgatory_FinalizePurchase)(nil), "CMsgRequestItemPurgatory_FinalizePurchase") + proto.RegisterType((*CMsgRequestItemPurgatory_FinalizePurchaseResponse)(nil), "CMsgRequestItemPurgatory_FinalizePurchaseResponse") + proto.RegisterType((*CMsgRequestItemPurgatory_RefundPurchase)(nil), "CMsgRequestItemPurgatory_RefundPurchase") + proto.RegisterType((*CMsgRequestItemPurgatory_RefundPurchaseResponse)(nil), "CMsgRequestItemPurgatory_RefundPurchaseResponse") + proto.RegisterType((*CMsgCraftingResponse)(nil), "CMsgCraftingResponse") + proto.RegisterType((*CMsgGCRequestStoreSalesData)(nil), "CMsgGCRequestStoreSalesData") + proto.RegisterType((*CMsgGCRequestStoreSalesDataResponse)(nil), "CMsgGCRequestStoreSalesDataResponse") + proto.RegisterType((*CMsgGCRequestStoreSalesDataResponse_Price)(nil), "CMsgGCRequestStoreSalesDataResponse.Price") + proto.RegisterType((*CMsgGCRequestStoreSalesDataUpToDateResponse)(nil), "CMsgGCRequestStoreSalesDataUpToDateResponse") + proto.RegisterType((*CMsgGCToGCPingRequest)(nil), "CMsgGCToGCPingRequest") + proto.RegisterType((*CMsgGCToGCPingResponse)(nil), "CMsgGCToGCPingResponse") + proto.RegisterType((*CMsgGCToGCGetUserSessionServer)(nil), "CMsgGCToGCGetUserSessionServer") + proto.RegisterType((*CMsgGCToGCGetUserSessionServerResponse)(nil), "CMsgGCToGCGetUserSessionServerResponse") + proto.RegisterType((*CMsgGCToGCGetUserServerMembers)(nil), "CMsgGCToGCGetUserServerMembers") + proto.RegisterType((*CMsgGCToGCGetUserServerMembersResponse)(nil), "CMsgGCToGCGetUserServerMembersResponse") + proto.RegisterType((*CMsgLookupMultipleAccountNames)(nil), "CMsgLookupMultipleAccountNames") + proto.RegisterType((*CMsgLookupMultipleAccountNamesResponse)(nil), "CMsgLookupMultipleAccountNamesResponse") + proto.RegisterType((*CMsgLookupMultipleAccountNamesResponse_Account)(nil), "CMsgLookupMultipleAccountNamesResponse.Account") + proto.RegisterType((*CMsgGCToGCGetUserPCBangNo)(nil), "CMsgGCToGCGetUserPCBangNo") + proto.RegisterType((*CMsgGCToGCGetUserPCBangNoResponse)(nil), "CMsgGCToGCGetUserPCBangNoResponse") + proto.RegisterType((*CMsgRequestCrateItems)(nil), "CMsgRequestCrateItems") + proto.RegisterType((*CMsgRequestCrateItemsResponse)(nil), "CMsgRequestCrateItemsResponse") + proto.RegisterType((*CMsgGCToGCCanUseDropRateBonus)(nil), "CMsgGCToGCCanUseDropRateBonus") + proto.RegisterType((*CMsgSQLAddDropRateBonus)(nil), "CMsgSQLAddDropRateBonus") + proto.RegisterType((*CMsgSQLUpgradeBattleBooster)(nil), "CMsgSQLUpgradeBattleBooster") + proto.RegisterType((*CMsgGCToGCRefreshSOCache)(nil), "CMsgGCToGCRefreshSOCache") + proto.RegisterType((*CMsgGCToGCCheckAccountTradeStatus)(nil), "CMsgGCToGCCheckAccountTradeStatus") + proto.RegisterType((*CMsgGCToGCCheckAccountTradeStatusResponse)(nil), "CMsgGCToGCCheckAccountTradeStatusResponse") + proto.RegisterType((*CMsgGCToGCGrantAccountRolledItems)(nil), "CMsgGCToGCGrantAccountRolledItems") + proto.RegisterType((*CMsgGCToGCGrantAccountRolledItems_Item)(nil), "CMsgGCToGCGrantAccountRolledItems.Item") + proto.RegisterType((*CMsgGCToGCGrantAccountRolledItems_Item_DynamicAttribute)(nil), "CMsgGCToGCGrantAccountRolledItems.Item.DynamicAttribute") + proto.RegisterType((*CMsgGCToGCGrantAccountRolledItems_Item_AdditionalAuditEntry)(nil), "CMsgGCToGCGrantAccountRolledItems.Item.AdditionalAuditEntry") + proto.RegisterType((*CMsgGCToGCGrantSelfMadeItemToAccount)(nil), "CMsgGCToGCGrantSelfMadeItemToAccount") + proto.RegisterType((*CMsgUseItem)(nil), "CMsgUseItem") + proto.RegisterType((*CMsgServerUseItem)(nil), "CMsgServerUseItem") + proto.RegisterType((*CMsgGCPartnerBalanceRequest)(nil), "CMsgGCPartnerBalanceRequest") + proto.RegisterType((*CMsgGCPartnerBalanceResponse)(nil), "CMsgGCPartnerBalanceResponse") + proto.RegisterType((*CGCStoreRechargeRedirect_LineItem)(nil), "CGCStoreRechargeRedirect_LineItem") + proto.RegisterType((*CMsgGCPartnerRechargeRedirectURLRequest)(nil), "CMsgGCPartnerRechargeRedirectURLRequest") + proto.RegisterType((*CMsgGCPartnerRechargeRedirectURLResponse)(nil), "CMsgGCPartnerRechargeRedirectURLResponse") + proto.RegisterType((*CMsgGCEconSQLWorkItemEmbeddedRollbackData)(nil), "CMsgGCEconSQLWorkItemEmbeddedRollbackData") + proto.RegisterType((*CMsgCraftStatue)(nil), "CMsgCraftStatue") + proto.RegisterType((*CMsgRedeemCode)(nil), "CMsgRedeemCode") + proto.RegisterType((*CMsgRedeemCodeResponse)(nil), "CMsgRedeemCodeResponse") + proto.RegisterType((*CMsgDevNewItemRequest)(nil), "CMsgDevNewItemRequest") + proto.RegisterType((*CMsgDevNewItemRequestResponse)(nil), "CMsgDevNewItemRequestResponse") + proto.RegisterType((*CMsgGCAddGiftItem)(nil), "CMsgGCAddGiftItem") + proto.RegisterType((*CMsgClientToGCWrapAndDeliverGift)(nil), "CMsgClientToGCWrapAndDeliverGift") + proto.RegisterType((*CMsgClientToGCWrapAndDeliverGiftResponse)(nil), "CMsgClientToGCWrapAndDeliverGiftResponse") + proto.RegisterType((*CMsgClientToGCUnwrapGift)(nil), "CMsgClientToGCUnwrapGift") + proto.RegisterType((*CMsgClientToGCUnpackBundle)(nil), "CMsgClientToGCUnpackBundle") + proto.RegisterType((*CMsgClientToGCUnpackBundleResponse)(nil), "CMsgClientToGCUnpackBundleResponse") + proto.RegisterType((*CMsgGCToClientStoreTransactionCompleted)(nil), "CMsgGCToClientStoreTransactionCompleted") + proto.RegisterType((*CMsgClientToGCEquipItems)(nil), "CMsgClientToGCEquipItems") + proto.RegisterType((*CMsgClientToGCEquipItemsResponse)(nil), "CMsgClientToGCEquipItemsResponse") + proto.RegisterType((*CMsgClientToGCSetItemStyle)(nil), "CMsgClientToGCSetItemStyle") + proto.RegisterType((*CMsgClientToGCSetItemStyleResponse)(nil), "CMsgClientToGCSetItemStyleResponse") + proto.RegisterType((*CMsgClientToGCUnlockItemStyle)(nil), "CMsgClientToGCUnlockItemStyle") + proto.RegisterType((*CMsgClientToGCUnlockItemStyleResponse)(nil), "CMsgClientToGCUnlockItemStyleResponse") + proto.RegisterType((*CMsgClientToGCSetItemInventoryCategory)(nil), "CMsgClientToGCSetItemInventoryCategory") + proto.RegisterType((*CMsgClientToGCUnlockCrate)(nil), "CMsgClientToGCUnlockCrate") + proto.RegisterType((*CMsgClientToGCUnlockCrateResponse)(nil), "CMsgClientToGCUnlockCrateResponse") + proto.RegisterType((*CMsgClientToGCUnlockCrateResponse_Item)(nil), "CMsgClientToGCUnlockCrateResponse.Item") + proto.RegisterType((*CMsgClientToGCRemoveItemAttribute)(nil), "CMsgClientToGCRemoveItemAttribute") + proto.RegisterType((*CMsgClientToGCRemoveItemAttributeResponse)(nil), "CMsgClientToGCRemoveItemAttributeResponse") + proto.RegisterType((*CMsgClientToGCNameItem)(nil), "CMsgClientToGCNameItem") + proto.RegisterType((*CMsgClientToGCNameItemResponse)(nil), "CMsgClientToGCNameItemResponse") + proto.RegisterType((*CMsgGCSetItemPosition)(nil), "CMsgGCSetItemPosition") + proto.RegisterType((*CAttribute_ItemDynamicRecipeComponent)(nil), "CAttribute_ItemDynamicRecipeComponent") + proto.RegisterType((*CProtoItemSocket)(nil), "CProtoItemSocket") + proto.RegisterType((*CProtoItemSocket_Empty)(nil), "CProtoItemSocket_Empty") + proto.RegisterType((*CProtoItemSocket_Effect)(nil), "CProtoItemSocket_Effect") + proto.RegisterType((*CProtoItemSocket_Color)(nil), "CProtoItemSocket_Color") + proto.RegisterType((*CProtoItemSocket_Strange)(nil), "CProtoItemSocket_Strange") + proto.RegisterType((*CProtoItemSocket_Spectator)(nil), "CProtoItemSocket_Spectator") + proto.RegisterType((*CProtoItemSocket_AssetModifier)(nil), "CProtoItemSocket_AssetModifier") + proto.RegisterType((*CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY)(nil), "CProtoItemSocket_AssetModifier_DESERIALIZE_FROM_STRING_ONLY") + proto.RegisterType((*CProtoItemSocket_Autograph)(nil), "CProtoItemSocket_Autograph") + proto.RegisterType((*CProtoItemSocket_StaticVisuals)(nil), "CProtoItemSocket_StaticVisuals") + proto.RegisterType((*CAttribute_String)(nil), "CAttribute_String") + proto.RegisterType((*CWorkshop_GetItemDailyRevenue_Request)(nil), "CWorkshop_GetItemDailyRevenue_Request") + proto.RegisterType((*CWorkshop_GetItemDailyRevenue_Response)(nil), "CWorkshop_GetItemDailyRevenue_Response") + proto.RegisterType((*CWorkshop_GetItemDailyRevenue_Response_CountryDailyRevenue)(nil), "CWorkshop_GetItemDailyRevenue_Response.CountryDailyRevenue") + proto.RegisterType((*CMsgGenericResult)(nil), "CMsgGenericResult") + proto.RegisterType((*CMsgSQLGCToGCGrantBackpackSlots)(nil), "CMsgSQLGCToGCGrantBackpackSlots") + proto.RegisterType((*CMsgClientToGCLookupAccountName)(nil), "CMsgClientToGCLookupAccountName") + proto.RegisterType((*CMsgClientToGCLookupAccountNameResponse)(nil), "CMsgClientToGCLookupAccountNameResponse") + proto.RegisterEnum("EGCItemMsg", EGCItemMsg_name, EGCItemMsg_value) + proto.RegisterEnum("EGCMsgResponse", EGCMsgResponse_name, EGCMsgResponse_value) + proto.RegisterEnum("EItemPurgatoryResponse_Finalize", EItemPurgatoryResponse_Finalize_name, EItemPurgatoryResponse_Finalize_value) + proto.RegisterEnum("EItemPurgatoryResponse_Refund", EItemPurgatoryResponse_Refund_name, EItemPurgatoryResponse_Refund_value) + proto.RegisterEnum("EGCPartnerRequestResponse", EGCPartnerRequestResponse_name, EGCPartnerRequestResponse_value) + proto.RegisterEnum("EGCMsgInitiateTradeResponse", EGCMsgInitiateTradeResponse_name, EGCMsgInitiateTradeResponse_value) + proto.RegisterEnum("CMsgRequestCrateItemsResponse_EResult", CMsgRequestCrateItemsResponse_EResult_name, CMsgRequestCrateItemsResponse_EResult_value) + proto.RegisterEnum("CMsgRedeemCodeResponse_EResultCode", CMsgRedeemCodeResponse_EResultCode_name, CMsgRedeemCodeResponse_EResultCode_value) + proto.RegisterEnum("CMsgClientToGCUnpackBundleResponse_EUnpackBundle", CMsgClientToGCUnpackBundleResponse_EUnpackBundle_name, CMsgClientToGCUnpackBundleResponse_EUnpackBundle_value) + proto.RegisterEnum("CMsgClientToGCSetItemStyleResponse_ESetStyle", CMsgClientToGCSetItemStyleResponse_ESetStyle_name, CMsgClientToGCSetItemStyleResponse_ESetStyle_value) + proto.RegisterEnum("CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle", CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle_name, CMsgClientToGCUnlockItemStyleResponse_EUnlockStyle_value) + proto.RegisterEnum("CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute", CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute_name, CMsgClientToGCRemoveItemAttributeResponse_ERemoveItemAttribute_value) + proto.RegisterEnum("CMsgClientToGCNameItemResponse_ENameItem", CMsgClientToGCNameItemResponse_ENameItem_name, CMsgClientToGCNameItemResponse_ENameItem_value) +} + +var econ_fileDescriptor0 = []byte{ + // 6148 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x3c, 0x69, 0x78, 0x24, 0xc7, + 0x55, 0x91, 0xb4, 0xda, 0x99, 0x2d, 0xad, 0x76, 0x6b, 0x7b, 0x66, 0x2f, 0x79, 0x7d, 0x8d, 0x13, + 0x7b, 0xbd, 0xf6, 0x8e, 0xe3, 0x5d, 0x3b, 0x71, 0xec, 0xc4, 0x46, 0x1a, 0xcd, 0x2a, 0xc2, 0xda, + 0x5d, 0x59, 0x23, 0xd9, 0x10, 0xbe, 0xa4, 0x69, 0x4d, 0x97, 0x46, 0x1d, 0xf5, 0x74, 0x8f, 0xbb, + 0x7b, 0x76, 0x35, 0xf9, 0x95, 0x83, 0x24, 0x5c, 0x39, 0x39, 0x3e, 0x20, 0x9c, 0x81, 0x1c, 0x10, + 0x02, 0x24, 0x5c, 0x5f, 0xb8, 0x13, 0x0c, 0x84, 0xf0, 0x41, 0x0e, 0x92, 0x00, 0x21, 0x09, 0x7c, + 0x1f, 0xe4, 0x3e, 0xc8, 0x7d, 0x27, 0xe6, 0xbd, 0xaa, 0xea, 0xee, 0xaa, 0xe9, 0x9e, 0xd6, 0x7c, + 0x1f, 0xfc, 0xb1, 0x35, 0x55, 0xaf, 0x5e, 0xbd, 0x7a, 0xf5, 0xee, 0x7a, 0xbd, 0xe4, 0x28, 0x6b, + 0xfb, 0x9e, 0xd9, 0x69, 0x77, 0x59, 0x18, 0x5a, 0x1d, 0x16, 0xd6, 0x7b, 0x81, 0x1f, 0xf9, 0x73, + 0x95, 0x30, 0x62, 0x56, 0x57, 0x1f, 0xac, 0x35, 0x89, 0xd1, 0xb8, 0x18, 0x76, 0xe6, 0x7b, 0x3d, + 0x77, 0x30, 0xdf, 0x8f, 0xfc, 0x4e, 0x60, 0xf5, 0xb6, 0x8d, 0x93, 0xe4, 0x88, 0x15, 0xff, 0x30, + 0x9d, 0x88, 0x75, 0x4d, 0xc7, 0x3e, 0x31, 0x71, 0xc3, 0xc4, 0xe9, 0x7d, 0x46, 0x95, 0x1c, 0x14, + 0x03, 0x72, 0x74, 0x12, 0x47, 0x6b, 0xdb, 0xe4, 0x1a, 0x8e, 0xc6, 0x7e, 0x6e, 0x3f, 0x8c, 0x96, + 0x61, 0xaa, 0xf9, 0x68, 0xdf, 0xe9, 0xf5, 0x98, 0xdd, 0x8a, 0xac, 0x88, 0x19, 0x87, 0x49, 0x49, + 0xc7, 0x72, 0x84, 0x1c, 0xf0, 0xd8, 0x55, 0xb3, 0xed, 0x5a, 0x61, 0xc8, 0x51, 0xcc, 0x1a, 0x94, + 0x94, 0x71, 0x28, 0x74, 0xfd, 0xe8, 0xc4, 0x14, 0x1f, 0xa9, 0x90, 0x99, 0x30, 0x1a, 0xb8, 0xcc, + 0x74, 0x3c, 0x9b, 0xed, 0x9e, 0xd8, 0x87, 0x83, 0xb5, 0x2f, 0x4c, 0x90, 0x27, 0xe2, 0x56, 0x4d, + 0x38, 0xe3, 0xaa, 0x6b, 0x0d, 0x58, 0xd0, 0x8a, 0x02, 0xcb, 0xeb, 0xb0, 0x86, 0xdf, 0xf7, 0x22, + 0x41, 0x40, 0x97, 0x79, 0x91, 0x61, 0x10, 0x62, 0xb5, 0xdb, 0x38, 0x18, 0x6f, 0x3b, 0x6b, 0xfc, + 0x30, 0x39, 0x19, 0x0a, 0x68, 0x53, 0xcc, 0x58, 0x09, 0x3c, 0x92, 0x31, 0x75, 0x7a, 0xe6, 0xdc, + 0x33, 0xea, 0xe3, 0x60, 0xaf, 0x37, 0xf2, 0xc7, 0xe7, 0xd6, 0xc8, 0xf1, 0xc6, 0x68, 0x82, 0xd8, + 0x15, 0xf8, 0xc3, 0x8c, 0x06, 0x3d, 0x26, 0x09, 0x52, 0x18, 0xc3, 0x19, 0xc9, 0xa9, 0x4e, 0x96, + 0x08, 0x3e, 0xd4, 0x9e, 0x41, 0x6e, 0x45, 0x9a, 0xd6, 0xd8, 0xa3, 0x7d, 0x26, 0xb8, 0xbb, 0xda, + 0x0f, 0x3a, 0x56, 0xe4, 0x07, 0x03, 0xf3, 0x82, 0xe3, 0x59, 0xae, 0xf3, 0x3c, 0x06, 0x23, 0xed, + 0x6d, 0x2b, 0x64, 0xc8, 0x46, 0x89, 0x31, 0x84, 0x3d, 0xa6, 0xe0, 0x6e, 0x36, 0xc8, 0x9d, 0x63, + 0x2f, 0x5f, 0x63, 0x61, 0xcf, 0xf7, 0x00, 0xcd, 0x21, 0xb2, 0x3f, 0x60, 0x61, 0xdf, 0x8d, 0x24, + 0xa1, 0x2a, 0xda, 0x49, 0x8e, 0xf6, 0x3e, 0x72, 0xcb, 0x48, 0xb4, 0x6b, 0x6c, 0xab, 0xef, 0xd9, + 0x05, 0x34, 0xcd, 0x93, 0x3b, 0xc6, 0x5c, 0x3c, 0x8a, 0xa2, 0xda, 0x69, 0x52, 0x45, 0x14, 0x8d, + 0xc0, 0xda, 0x8a, 0x1c, 0xaf, 0x93, 0xc0, 0x65, 0x37, 0xfb, 0x3e, 0x21, 0x9c, 0x4b, 0x0d, 0xb9, + 0x5d, 0x0b, 0xb6, 0x61, 0x2d, 0xcb, 0x65, 0xe1, 0xa2, 0x15, 0x59, 0x78, 0x07, 0x57, 0x58, 0x10, + 0x3a, 0xbe, 0x97, 0x9e, 0xb5, 0xdd, 0x0f, 0x02, 0xe6, 0xb5, 0x07, 0x42, 0x36, 0x6b, 0x6f, 0x9b, + 0x20, 0x37, 0x15, 0xa0, 0x48, 0xf6, 0xbe, 0x9f, 0x90, 0x10, 0x06, 0xcd, 0x5e, 0xe0, 0xb4, 0x19, + 0xdf, 0x7d, 0xe6, 0xdc, 0x99, 0xfa, 0x18, 0x2b, 0xeb, 0xab, 0xb8, 0x42, 0x25, 0x45, 0x28, 0xc5, + 0x71, 0x72, 0x98, 0xed, 0xf6, 0x9c, 0xc0, 0x8a, 0x60, 0xcc, 0x8c, 0x9c, 0x2e, 0x13, 0x32, 0x31, + 0x77, 0x9a, 0x4c, 0x8b, 0x25, 0xf1, 0x71, 0x6d, 0xb6, 0x25, 0xc9, 0x9f, 0x25, 0xd3, 0x62, 0x7f, + 0x41, 0xfb, 0x23, 0xe4, 0xb6, 0x02, 0x02, 0x36, 0x7a, 0xeb, 0x3e, 0xfc, 0x3f, 0x65, 0x73, 0x86, + 0x1b, 0x39, 0x24, 0x08, 0xc4, 0xc7, 0xc9, 0x51, 0x81, 0x78, 0xdd, 0x5f, 0x6a, 0xac, 0xf2, 0x2b, + 0xe0, 0x1b, 0xd4, 0x4e, 0x90, 0x63, 0xc3, 0x13, 0x02, 0x79, 0xed, 0x2e, 0x72, 0x5d, 0x3a, 0xb3, + 0xc4, 0xa2, 0x8d, 0x10, 0x14, 0x0c, 0x0c, 0x12, 0x60, 0x6e, 0xb1, 0x00, 0xf6, 0xcd, 0xd3, 0x5a, + 0x10, 0x96, 0x9b, 0x8b, 0x57, 0x25, 0xc4, 0x03, 0xad, 0x21, 0x1f, 0x31, 0xb9, 0xad, 0x8b, 0x51, + 0xec, 0xaf, 0xad, 0xe4, 0x6e, 0x8c, 0x90, 0x17, 0x59, 0x77, 0x13, 0xce, 0x9b, 0x6b, 0x2e, 0x8e, + 0x91, 0x43, 0x5d, 0x6b, 0xd7, 0x0c, 0x7b, 0xac, 0x1d, 0xa1, 0x6c, 0x4a, 0x53, 0x55, 0x6b, 0xe4, + 0x12, 0xa4, 0x60, 0x4b, 0x08, 0x02, 0x43, 0xda, 0xe5, 0x43, 0xa6, 0x86, 0x7c, 0x0a, 0x90, 0xdc, + 0x23, 0x48, 0x5a, 0xf1, 0xfd, 0x9d, 0x7e, 0xef, 0x22, 0xc8, 0xb5, 0xd3, 0x73, 0xd9, 0xbc, 0x80, + 0xba, 0x64, 0x81, 0x99, 0x86, 0xed, 0x63, 0x92, 0x62, 0x59, 0x9e, 0x5d, 0x98, 0xa4, 0x13, 0xb5, + 0x5f, 0x98, 0x10, 0xfb, 0x8f, 0x5e, 0x9a, 0xec, 0x3f, 0x4f, 0xca, 0x12, 0x45, 0x28, 0xc5, 0xf1, + 0x8e, 0xfa, 0x78, 0x4b, 0xeb, 0x72, 0x70, 0xee, 0x2c, 0x29, 0xc9, 0x3f, 0xd1, 0x6a, 0x27, 0x04, + 0xa5, 0x06, 0xac, 0x07, 0x07, 0xf6, 0x3d, 0x8b, 0xf3, 0xe6, 0x40, 0xed, 0x0e, 0x72, 0x32, 0xc3, + 0x9b, 0xd5, 0xc6, 0x02, 0x18, 0xc4, 0x4b, 0x7e, 0xee, 0xed, 0x3e, 0x95, 0xdc, 0x38, 0x72, 0x41, + 0x72, 0x0e, 0x58, 0xd8, 0x6b, 0x9b, 0x9b, 0x30, 0x68, 0x7a, 0xbe, 0x5c, 0x78, 0x87, 0x90, 0x3f, + 0x29, 0x75, 0x60, 0x07, 0x22, 0x86, 0x86, 0x04, 0xf9, 0x76, 0xa8, 0x8d, 0xbf, 0x4c, 0x5d, 0x31, + 0x6a, 0x1e, 0xb9, 0x36, 0x77, 0x81, 0x6a, 0x3a, 0x02, 0xf9, 0xb7, 0x3c, 0x1e, 0x9c, 0x38, 0x46, + 0x22, 0xec, 0x1e, 0xda, 0x9d, 0x52, 0x73, 0x8d, 0x1b, 0x22, 0x38, 0xfc, 0xcc, 0x8e, 0xd9, 0xea, + 0xb7, 0xdb, 0x8c, 0xd9, 0xcc, 0xa6, 0x4f, 0x30, 0x0e, 0x92, 0xf2, 0x8e, 0x79, 0xc1, 0x72, 0x5c, + 0xf8, 0x35, 0x51, 0xfb, 0xb9, 0x09, 0xb1, 0xa1, 0x38, 0x5a, 0xc3, 0xf2, 0xe0, 0x68, 0x8b, 0x81, + 0xdf, 0x5b, 0x83, 0x8d, 0x17, 0x7c, 0xaf, 0x9f, 0x2f, 0x74, 0x20, 0xc3, 0x36, 0x00, 0x99, 0xfc, + 0x04, 0x9b, 0x08, 0xc6, 0x39, 0x3b, 0x89, 0x9e, 0x77, 0xd3, 0xf7, 0x41, 0xb0, 0x03, 0xe1, 0x41, + 0x84, 0x93, 0x9c, 0x23, 0x06, 0xdb, 0x6d, 0xbb, 0xfd, 0xd0, 0xb9, 0xa2, 0x1c, 0x98, 0xfb, 0x4a, + 0xe3, 0x04, 0xa1, 0x96, 0xeb, 0xfa, 0x57, 0x4d, 0x38, 0xb1, 0xe5, 0x72, 0x8c, 0x27, 0xa6, 0x61, + 0xa6, 0x5c, 0x7b, 0xcb, 0x04, 0xf8, 0x29, 0x20, 0xad, 0xf5, 0xd0, 0xca, 0xbc, 0x6d, 0xef, 0x4d, + 0x54, 0xc6, 0x4f, 0xa9, 0x66, 0x67, 0x6a, 0x14, 0xdd, 0xfb, 0x72, 0xe9, 0x9e, 0x8e, 0x69, 0x0b, + 0x31, 0x4e, 0xb1, 0x43, 0xd3, 0xee, 0x0b, 0xe3, 0x72, 0x62, 0x7f, 0xac, 0x75, 0xcc, 0xb3, 0xb9, + 0xa5, 0x01, 0x35, 0xb6, 0xba, 0xbd, 0x13, 0x25, 0x7e, 0x7d, 0xbe, 0x30, 0xe3, 0x40, 0xf2, 0x46, + 0x0f, 0x22, 0x13, 0x9b, 0x2d, 0x58, 0x51, 0xe4, 0x02, 0xd1, 0x1c, 0x77, 0x2e, 0xd9, 0x2a, 0x95, + 0xc2, 0xa0, 0x72, 0x62, 0x80, 0x36, 0x33, 0xf2, 0xc1, 0xf9, 0xdb, 0x9c, 0xf6, 0x2c, 0x89, 0x22, + 0xd4, 0xb8, 0x9f, 0x9c, 0x48, 0xaf, 0x0f, 0xbc, 0x12, 0xc8, 0xc6, 0x76, 0xeb, 0x72, 0xc3, 0x6a, + 0x6f, 0xb3, 0xdc, 0xdd, 0xb8, 0x87, 0x72, 0x7d, 0x4b, 0xf0, 0xa8, 0x5c, 0xfb, 0x7e, 0x55, 0xb2, + 0x1b, 0xdb, 0xac, 0xbd, 0x23, 0x15, 0x69, 0x1d, 0xa9, 0xc7, 0xc8, 0x68, 0x04, 0xb7, 0x51, 0xea, + 0x3c, 0x27, 0x72, 0xd0, 0xe6, 0x48, 0x5c, 0x6b, 0x22, 0x06, 0x28, 0xc4, 0x95, 0xc8, 0x31, 0xac, + 0x6f, 0x5b, 0x60, 0xab, 0x71, 0x8a, 0xa3, 0x2c, 0xf3, 0xe0, 0x23, 0x08, 0xfc, 0x00, 0xe2, 0x1e, + 0x3b, 0x36, 0xe0, 0x1f, 0xdf, 0xa7, 0xa9, 0x1e, 0x04, 0x2d, 0x91, 0x44, 0xba, 0xe6, 0xbb, 0x20, + 0xc2, 0x42, 0x9b, 0xf2, 0x08, 0x7c, 0x0a, 0x99, 0x46, 0xbe, 0xc6, 0x31, 0xd3, 0x2d, 0xf5, 0x3d, + 0xd1, 0xd4, 0xf1, 0xbf, 0xc8, 0x67, 0xab, 0x6f, 0x3b, 0x10, 0x77, 0xb5, 0xf9, 0x85, 0x0b, 0xc9, + 0xc1, 0x1d, 0xf8, 0xa8, 0x0d, 0x0e, 0x49, 0xf0, 0x7e, 0xee, 0x5d, 0x53, 0x64, 0x1f, 0x5f, 0x92, + 0xf5, 0x6f, 0x00, 0xee, 0xfa, 0x7e, 0x64, 0xba, 0x4e, 0x28, 0xa3, 0xb6, 0x03, 0x3c, 0x2a, 0xed, + 0x78, 0xe0, 0xd8, 0x60, 0xb4, 0xeb, 0x88, 0xc0, 0xa9, 0x8c, 0x17, 0xe2, 0x07, 0x4e, 0xc7, 0xf1, + 0xa4, 0x3e, 0xac, 0x13, 0xc3, 0x1e, 0x78, 0x56, 0xd7, 0x69, 0x9b, 0x20, 0x3a, 0x81, 0xb3, 0xd9, + 0x8f, 0x58, 0x08, 0xf2, 0x88, 0x67, 0xb8, 0x67, 0xcc, 0x33, 0xd4, 0x17, 0x05, 0x86, 0xf9, 0x18, + 0x81, 0xf1, 0x1c, 0x72, 0x02, 0x24, 0xc9, 0xc1, 0x03, 0x81, 0x92, 0x89, 0x93, 0x40, 0xf0, 0x16, + 0x38, 0x80, 0x7b, 0x3f, 0xc7, 0xfd, 0xf4, 0x71, 0x71, 0xcf, 0x27, 0x78, 0xe6, 0x11, 0x4d, 0x13, + 0xb0, 0x0c, 0x50, 0xb1, 0x1c, 0x0f, 0x03, 0x47, 0x0c, 0x8e, 0x22, 0x7f, 0x87, 0x79, 0x42, 0x21, + 0xe6, 0x1e, 0x24, 0x34, 0x43, 0xcc, 0x41, 0xb2, 0x0f, 0x46, 0xc4, 0xad, 0x73, 0xb6, 0x5c, 0xb1, + 0xdc, 0x3e, 0x33, 0xfb, 0x8e, 0x17, 0x9d, 0x3f, 0x27, 0x75, 0x00, 0xe2, 0x6a, 0x31, 0xba, 0x05, + 0xc2, 0x2a, 0x78, 0x35, 0x39, 0xf7, 0x2c, 0x52, 0xcd, 0xdd, 0x1d, 0xf4, 0xd4, 0xbf, 0xea, 0x0d, + 0x3b, 0x30, 0xa9, 0x4a, 0xda, 0x65, 0x4e, 0xe6, 0x5c, 0xa6, 0x08, 0x60, 0x1f, 0x12, 0x21, 0xbb, + 0xc2, 0x80, 0x16, 0x73, 0xb7, 0x2e, 0x82, 0x74, 0xe2, 0xa9, 0xd7, 0xfd, 0xd8, 0xbf, 0x80, 0xe6, + 0xc7, 0x77, 0x2d, 0x63, 0xfe, 0x44, 0x1f, 0x52, 0xbf, 0x23, 0x64, 0x17, 0x0c, 0xd8, 0x0c, 0xe2, + 0x04, 0x93, 0xca, 0xc5, 0x24, 0x93, 0x61, 0x00, 0xd7, 0x22, 0x2b, 0xe8, 0xb0, 0x28, 0x0d, 0x05, + 0x70, 0xe5, 0x7e, 0xe3, 0x7a, 0x72, 0xbc, 0xe3, 0x6c, 0x45, 0xa6, 0xd9, 0xf3, 0x23, 0x60, 0xaa, + 0x03, 0x77, 0x26, 0x00, 0x43, 0xa0, 0x76, 0x4a, 0x58, 0x26, 0xbb, 0xcf, 0x5c, 0x53, 0x64, 0x27, + 0xa6, 0xeb, 0xb7, 0x77, 0xa4, 0xfc, 0x80, 0xad, 0x4d, 0xf4, 0x32, 0x45, 0x3b, 0xcd, 0xf7, 0xbb, + 0x91, 0x9c, 0x44, 0x02, 0x7a, 0x56, 0x7b, 0xc7, 0x34, 0xf1, 0x3f, 0x0e, 0xa4, 0x5a, 0x36, 0x80, + 0x32, 0x77, 0xc0, 0x0d, 0x5b, 0x19, 0x02, 0xf1, 0x23, 0xdc, 0x80, 0xf1, 0x48, 0x21, 0x26, 0xfc, + 0x14, 0xa9, 0xa6, 0x38, 0x33, 0x3c, 0xae, 0x91, 0x83, 0xfd, 0x50, 0xda, 0xf5, 0x6e, 0xd8, 0xe1, + 0x47, 0x98, 0x39, 0x77, 0xb0, 0xae, 0x1c, 0xbd, 0x76, 0x6d, 0x1c, 0xde, 0xae, 0x5a, 0x41, 0x04, + 0x37, 0xb5, 0x60, 0xb9, 0x96, 0xd7, 0x66, 0x71, 0x34, 0xd6, 0x23, 0xa7, 0xf2, 0xa7, 0xa5, 0xb1, + 0x78, 0x40, 0x8b, 0xab, 0x0f, 0x9d, 0x9b, 0xab, 0x37, 0x13, 0x58, 0x89, 0x23, 0x86, 0xbd, 0xb7, + 0xb2, 0x63, 0x36, 0xf5, 0xa9, 0xcb, 0x0f, 0x22, 0xeb, 0x37, 0x05, 0x4e, 0x79, 0x37, 0x68, 0xf7, + 0x96, 0x1a, 0x3c, 0xce, 0x5c, 0x63, 0x10, 0xc4, 0x03, 0x73, 0xd7, 0x80, 0x15, 0x01, 0x44, 0x51, + 0xe6, 0x8a, 0xe3, 0x89, 0x73, 0x83, 0x10, 0xa6, 0x77, 0xad, 0xd8, 0x6b, 0xf0, 0x54, 0x70, 0x29, + 0x51, 0x1c, 0x79, 0x5b, 0x22, 0xcb, 0x50, 0x28, 0xd2, 0x11, 0x6e, 0xac, 0xad, 0x48, 0x4a, 0xc0, + 0x28, 0x11, 0x17, 0xb0, 0x9b, 0xc2, 0x32, 0x89, 0x68, 0xa7, 0x56, 0xdf, 0x93, 0x92, 0xda, 0x2e, + 0x39, 0xbd, 0xf7, 0x16, 0xff, 0x5f, 0xcc, 0x9a, 0x21, 0x53, 0xfd, 0xc0, 0x95, 0xb1, 0xd2, 0x0f, + 0xc4, 0x46, 0x1d, 0xd3, 0x4d, 0xf0, 0x6b, 0x8f, 0xf8, 0xc1, 0x0e, 0x4f, 0x9e, 0x21, 0x62, 0xb4, + 0x21, 0xa2, 0x40, 0xfb, 0xb0, 0x09, 0xb2, 0xc4, 0xd3, 0x94, 0x51, 0xb1, 0x02, 0x73, 0x59, 0xc4, + 0xec, 0xa1, 0x7c, 0xfc, 0xc5, 0x13, 0xe4, 0x70, 0x92, 0x1d, 0x71, 0xef, 0xc0, 0x13, 0xa8, 0x6d, + 0x16, 0xf8, 0xaa, 0xfe, 0x86, 0x48, 0x17, 0x5c, 0x1c, 0x37, 0x19, 0x9c, 0x26, 0xcc, 0x1e, 0xda, + 0x83, 0xb6, 0xcb, 0xa4, 0x67, 0x84, 0x6b, 0xb2, 0x59, 0xd8, 0x0e, 0x9c, 0x1e, 0xd7, 0xf1, 0x7d, + 0x1c, 0x06, 0x34, 0x04, 0x52, 0x7b, 0x38, 0x10, 0xe8, 0x0e, 0xee, 0x8b, 0xb6, 0x79, 0x3a, 0x76, + 0x81, 0x91, 0xef, 0xbb, 0xb0, 0xc7, 0x7e, 0x4e, 0xc7, 0x75, 0xe4, 0x90, 0x08, 0xb9, 0x6c, 0xc6, + 0xba, 0x0d, 0x70, 0x3d, 0x68, 0xa0, 0xb8, 0x0b, 0xe2, 0x06, 0xaa, 0xf6, 0xe6, 0x09, 0x91, 0x2b, + 0xa4, 0x00, 0x05, 0xc1, 0xd8, 0x70, 0x10, 0x02, 0xa2, 0x3d, 0x23, 0x43, 0x31, 0x8e, 0x3a, 0x13, + 0x8e, 0x9d, 0x24, 0x47, 0xe3, 0x70, 0xcc, 0x44, 0x88, 0x4b, 0x7e, 0x74, 0x01, 0x18, 0x08, 0xb1, + 0x19, 0xa8, 0xdd, 0x09, 0x6d, 0x6a, 0xde, 0x0d, 0x98, 0x65, 0x0f, 0x40, 0xa7, 0x6c, 0x3a, 0x09, + 0x7c, 0xad, 0x24, 0xb3, 0x97, 0x23, 0xe0, 0x5a, 0x13, 0x7d, 0x27, 0x9d, 0xaa, 0x3d, 0x2a, 0x62, + 0xce, 0x45, 0x76, 0xe5, 0x12, 0xbb, 0x8a, 0x57, 0x15, 0x0b, 0xdf, 0x51, 0x32, 0x9b, 0x88, 0x33, + 0xe7, 0xe6, 0x14, 0xe7, 0x14, 0x58, 0xb4, 0xc4, 0x57, 0x89, 0x71, 0xc1, 0x41, 0x00, 0x47, 0x0f, + 0x94, 0x82, 0x4f, 0x73, 0x37, 0x86, 0x77, 0x8c, 0xc3, 0xdc, 0x3c, 0x73, 0xe7, 0x71, 0xa0, 0xf6, + 0x64, 0x11, 0x44, 0x66, 0xb6, 0x54, 0x33, 0xb6, 0x10, 0x0f, 0x1d, 0x86, 0xc2, 0xd7, 0x43, 0x66, + 0x71, 0x44, 0x88, 0x15, 0x18, 0xf4, 0x25, 0x30, 0x75, 0x5c, 0xdf, 0xc6, 0x89, 0xea, 0x6a, 0x8c, + 0xdc, 0xc0, 0xa5, 0xc6, 0x75, 0xc0, 0x32, 0xa2, 0xb1, 0x7e, 0x24, 0xb0, 0x7a, 0xf3, 0x9e, 0xbd, + 0xc8, 0x5c, 0x08, 0x2f, 0x03, 0x44, 0x96, 0xb5, 0xb4, 0x60, 0x15, 0x3b, 0x18, 0x7c, 0x62, 0x44, + 0x95, 0xee, 0x90, 0x84, 0x5b, 0xdc, 0xd8, 0xca, 0xaa, 0x93, 0xe0, 0x4a, 0xed, 0xb1, 0x49, 0xa1, + 0x72, 0x45, 0xfb, 0x24, 0xc7, 0xbb, 0x7b, 0x48, 0x0e, 0x0e, 0x9d, 0x3b, 0x8c, 0x4a, 0xc7, 0x85, + 0x46, 0x6a, 0x9a, 0x01, 0x9a, 0xa6, 0x8d, 0x80, 0xa2, 0x5d, 0x43, 0x2a, 0xb8, 0x33, 0x64, 0x9f, + 0xa6, 0x50, 0x67, 0x13, 0x0c, 0x69, 0x5c, 0x6b, 0xe2, 0x24, 0x6b, 0x93, 0x90, 0xe7, 0x71, 0xe2, + 0xa6, 0x63, 0x92, 0x71, 0x8e, 0xaf, 0xd8, 0x17, 0xfb, 0xcc, 0x78, 0x14, 0x41, 0xa7, 0x39, 0x28, + 0xd8, 0xee, 0x78, 0xf0, 0x2a, 0xf8, 0x2b, 0x08, 0xb4, 0xb7, 0xfd, 0x7e, 0x10, 0xca, 0x38, 0xd6, + 0x24, 0x47, 0x78, 0x04, 0x66, 0x02, 0xf9, 0xe0, 0x9e, 0x85, 0x93, 0x2c, 0xf1, 0x13, 0x9c, 0x92, + 0x27, 0x58, 0x16, 0x96, 0x9f, 0xf1, 0x20, 0x2e, 0x39, 0xce, 0xcd, 0xf1, 0x71, 0x72, 0xa7, 0x4d, + 0xf0, 0x96, 0xac, 0x07, 0x2a, 0x5f, 0xbb, 0x4d, 0xc4, 0xa7, 0x29, 0x17, 0x37, 0xbc, 0xab, 0xc0, + 0xc7, 0xdc, 0x5b, 0xaa, 0x9d, 0x25, 0x73, 0xc3, 0xc0, 0xe8, 0xab, 0x16, 0x40, 0x1d, 0xdc, 0x6c, + 0x81, 0xae, 0xf6, 0xa1, 0x29, 0x52, 0x1b, 0x0d, 0xaf, 0xe6, 0xb7, 0x7d, 0x3e, 0x9e, 0x5a, 0x20, + 0x59, 0x75, 0x31, 0x9e, 0xad, 0xdc, 0xdb, 0x24, 0x3f, 0xf5, 0x9d, 0xf5, 0xbd, 0x31, 0xd6, 0x9b, + 0xea, 0xe8, 0xbd, 0xa0, 0xa4, 0xea, 0xef, 0x54, 0xbb, 0x6b, 0x6f, 0x9b, 0x24, 0xb3, 0x1a, 0xac, + 0x50, 0xe9, 0x7c, 0x68, 0xb0, 0x05, 0xb7, 0x92, 0x27, 0x0d, 0xcd, 0x4a, 0xfd, 0x46, 0xed, 0x58, + 0x0e, 0xc1, 0x34, 0x88, 0x61, 0xb0, 0x0d, 0x77, 0x93, 0x3b, 0xf3, 0x41, 0x37, 0x3c, 0x6b, 0xd3, + 0x65, 0xeb, 0x7e, 0x03, 0x6c, 0x45, 0xc4, 0x1a, 0xbe, 0x17, 0x59, 0xe0, 0x44, 0x78, 0x00, 0x07, + 0x46, 0xe3, 0x66, 0x52, 0xcb, 0x5f, 0x26, 0x73, 0x06, 0x69, 0x43, 0x8c, 0x5b, 0xc8, 0x4d, 0x45, + 0x94, 0x2c, 0x7b, 0xa0, 0xfd, 0x8e, 0x4d, 0xf7, 0x8d, 0x26, 0x79, 0xc1, 0xe2, 0x7b, 0x3e, 0x24, + 0x5d, 0x25, 0x9d, 0x36, 0x6e, 0x27, 0xa7, 0x8b, 0x49, 0x5e, 0xe4, 0x6e, 0x82, 0x53, 0xba, 0xbf, + 0xf6, 0x60, 0xec, 0x54, 0xe1, 0x28, 0xfc, 0x36, 0xb8, 0x87, 0x04, 0x29, 0xf3, 0x42, 0x11, 0xcb, + 0x35, 0xfc, 0x6e, 0x8f, 0xbb, 0x15, 0x6e, 0xd0, 0x77, 0xbd, 0x54, 0xd9, 0xb3, 0x75, 0xc0, 0x67, + 0x0e, 0x4b, 0x21, 0x2f, 0xfd, 0x8a, 0xdc, 0xe1, 0x76, 0xb2, 0x9f, 0xe1, 0xaf, 0xd8, 0x1d, 0x9f, + 0xaa, 0x17, 0x54, 0x89, 0x6b, 0x0f, 0x0c, 0x5b, 0x9f, 0x14, 0x53, 0x22, 0x70, 0xa0, 0xd6, 0xa1, + 0x6f, 0xb6, 0x91, 0x9f, 0xa6, 0xac, 0x53, 0xa5, 0x55, 0x9e, 0x85, 0x61, 0x19, 0x6f, 0x31, 0xbe, + 0x4d, 0x0b, 0xab, 0xc8, 0x59, 0xc3, 0x35, 0x54, 0x5f, 0x16, 0x01, 0xc7, 0x47, 0x27, 0x86, 0x05, + 0x5f, 0x45, 0x92, 0xd0, 0xb1, 0x91, 0xb1, 0x4a, 0x67, 0xeb, 0x7b, 0x2f, 0xab, 0x37, 0x61, 0x94, + 0x8f, 0xdc, 0x5b, 0x05, 0x57, 0x25, 0xff, 0x56, 0xa4, 0xda, 0x22, 0x07, 0x12, 0x10, 0x70, 0xb3, + 0xb9, 0x40, 0x20, 0xcc, 0x47, 0xc9, 0x11, 0x65, 0x26, 0x2e, 0x38, 0x18, 0x37, 0x91, 0xeb, 0x33, + 0xc3, 0x26, 0xff, 0xb1, 0x1c, 0xae, 0xf8, 0xa8, 0xa4, 0x74, 0xb2, 0xe6, 0x08, 0x7f, 0xa2, 0xaa, + 0x21, 0x86, 0xb8, 0x29, 0x9f, 0xe2, 0x28, 0x1c, 0xec, 0x79, 0x9f, 0x4f, 0x15, 0xb0, 0x0b, 0xef, + 0x03, 0x62, 0x97, 0xb0, 0xdf, 0x45, 0x31, 0x4b, 0x4d, 0xc0, 0x14, 0x17, 0x8d, 0xd7, 0x4e, 0x93, + 0x27, 0x15, 0xee, 0x95, 0xb0, 0xf3, 0x39, 0x19, 0x76, 0x9e, 0xaf, 0x8f, 0xb5, 0x12, 0xed, 0x05, + 0x4e, 0x08, 0xa6, 0x1e, 0x47, 0x25, 0x48, 0x7e, 0xa6, 0x2c, 0xcb, 0xd6, 0x2f, 0x86, 0x0e, 0x33, + 0x95, 0x44, 0x44, 0x7c, 0xb0, 0x17, 0xb0, 0x80, 0x3d, 0x2a, 0xcb, 0x00, 0x1f, 0x9e, 0x22, 0x07, + 0xd5, 0x5d, 0xe0, 0xcc, 0xa3, 0xf6, 0x81, 0xab, 0xb9, 0x9e, 0x5c, 0xa3, 0x4f, 0xca, 0x6b, 0x58, + 0xc5, 0x10, 0xf4, 0xd1, 0xf8, 0x92, 0x72, 0x00, 0x1a, 0x98, 0x17, 0x6e, 0x6d, 0xf9, 0x01, 0x06, + 0x20, 0x45, 0x40, 0xa0, 0x9c, 0x90, 0xe2, 0x82, 0x21, 0x91, 0x06, 0x27, 0x17, 0x08, 0xaf, 0x9b, + 0x5b, 0x9d, 0xd4, 0x8e, 0x14, 0xec, 0x28, 0xf2, 0x47, 0xb0, 0x23, 0x45, 0x28, 0x05, 0xe8, 0x12, + 0x5a, 0x10, 0xe3, 0x0c, 0xb9, 0x39, 0x17, 0xee, 0x92, 0x8f, 0xa6, 0x83, 0x79, 0xb6, 0xd3, 0xef, + 0xae, 0xb0, 0x2b, 0xcc, 0xa5, 0x25, 0xe3, 0x34, 0x79, 0x62, 0x2e, 0x6c, 0x1c, 0x72, 0xf1, 0x19, + 0xe0, 0x5d, 0x79, 0xe4, 0xa9, 0x95, 0x10, 0xec, 0xc0, 0x48, 0x12, 0x75, 0xeb, 0x49, 0x46, 0xc2, + 0xad, 0x43, 0x7c, 0x9a, 0xc2, 0xcd, 0xd4, 0x5e, 0x24, 0xab, 0xa9, 0x19, 0xcd, 0x5d, 0x8e, 0x93, + 0xee, 0x06, 0x18, 0xa7, 0x0e, 0xfc, 0x3f, 0xfb, 0xb4, 0x20, 0x62, 0xe8, 0x08, 0x55, 0x45, 0x84, + 0x6c, 0x42, 0x29, 0xc0, 0x2b, 0x06, 0xac, 0xeb, 0x43, 0x4c, 0xd4, 0x16, 0x4b, 0xb1, 0x14, 0x30, + 0x15, 0x17, 0xb7, 0x2c, 0xdb, 0x56, 0xc7, 0x85, 0x90, 0x2d, 0x89, 0xb2, 0xe9, 0xb0, 0xbc, 0xf3, + 0x22, 0x25, 0x46, 0x8b, 0x4a, 0x41, 0x53, 0xb5, 0x5f, 0x3b, 0x6c, 0x30, 0x14, 0xf9, 0x3f, 0x36, + 0x21, 0x8a, 0x3a, 0xb9, 0x98, 0x12, 0x7d, 0x3b, 0x3f, 0x94, 0xc7, 0x8c, 0x15, 0x52, 0xdd, 0x4f, + 0x66, 0x3b, 0x98, 0xbc, 0x4b, 0x5f, 0xaf, 0x57, 0x7f, 0x0a, 0xf7, 0xe3, 0xd5, 0x8d, 0xb9, 0x33, + 0xb2, 0xa4, 0x93, 0xf7, 0x1a, 0x98, 0xa6, 0xfc, 0xc2, 0x0c, 0xdf, 0x35, 0x7c, 0x8a, 0x35, 0xce, + 0x50, 0x5c, 0x9f, 0x16, 0x3b, 0x32, 0x51, 0xcb, 0x5b, 0xa7, 0x44, 0x46, 0x55, 0xb8, 0x2c, 0x61, + 0x42, 0x90, 0x31, 0x3a, 0x0f, 0xd4, 0xc7, 0x5e, 0x5d, 0x6f, 0xe6, 0x4c, 0xde, 0x0b, 0xf2, 0x9b, + 0x33, 0x5c, 0x60, 0x88, 0x6a, 0x8f, 0x4f, 0x90, 0x6a, 0x1e, 0x2a, 0xa1, 0x0c, 0x85, 0xc8, 0xc0, + 0xda, 0xdc, 0x40, 0x4e, 0xe5, 0x03, 0x25, 0x3e, 0xa1, 0x4e, 0xce, 0x14, 0x41, 0x0c, 0xa9, 0xcd, + 0xa4, 0xf1, 0x34, 0x72, 0x77, 0x21, 0x7c, 0x32, 0x00, 0x26, 0xc1, 0x83, 0xa0, 0x89, 0x09, 0x58, + 0x1b, 0xec, 0x11, 0x8f, 0x9b, 0xc6, 0x59, 0xba, 0xe8, 0xb3, 0xd0, 0x8b, 0x9a, 0xbb, 0x90, 0x14, + 0x51, 0x7c, 0x9f, 0x3c, 0xa6, 0x73, 0x1d, 0xdf, 0x21, 0xb8, 0xa0, 0xe0, 0x73, 0x4e, 0x7f, 0xf3, + 0xb9, 0x98, 0xad, 0x67, 0x1e, 0xa1, 0x31, 0xcd, 0xd4, 0x45, 0x3f, 0xa9, 0x7d, 0x89, 0x24, 0xe3, + 0xad, 0x93, 0xe2, 0x81, 0x25, 0x8b, 0x37, 0x11, 0x80, 0x87, 0x32, 0x02, 0x70, 0x6b, 0xbd, 0x78, + 0x49, 0xbd, 0x19, 0x8f, 0xa0, 0x03, 0x8f, 0xff, 0x2e, 0xba, 0xdf, 0x37, 0x4d, 0x80, 0x4b, 0x4f, + 0x4e, 0xc4, 0x5d, 0x7a, 0x76, 0x59, 0xec, 0xd2, 0x93, 0x19, 0xdd, 0xa5, 0x0f, 0x0d, 0x0f, 0x99, + 0xb0, 0xc9, 0x7c, 0x20, 0xfd, 0x62, 0xa7, 0xf2, 0x81, 0xf8, 0xef, 0x34, 0xe4, 0xac, 0xdd, 0x1f, + 0xbf, 0xe9, 0x49, 0x1b, 0xb8, 0xea, 0x87, 0xbc, 0x24, 0x98, 0xd5, 0x59, 0xb8, 0x02, 0x7c, 0xae, + 0xef, 0x49, 0x00, 0xa9, 0xb6, 0x9f, 0x9b, 0x00, 0x8f, 0x9f, 0x5e, 0x3c, 0xa2, 0x90, 0x25, 0xca, + 0x35, 0xd6, 0x76, 0x7a, 0x0c, 0xbd, 0x83, 0xef, 0xe1, 0x6b, 0x78, 0xb6, 0xae, 0x1b, 0x77, 0x16, + 0xe0, 0x5b, 0x45, 0x52, 0x00, 0xc2, 0xbc, 0x95, 0x8f, 0x6e, 0xb9, 0x56, 0x27, 0x36, 0xa2, 0xd8, + 0x9e, 0x90, 0xd4, 0x6f, 0x4d, 0x4c, 0xae, 0xbc, 0x8e, 0x4c, 0xac, 0x63, 0x70, 0x9e, 0x87, 0xca, + 0xa2, 0x04, 0x16, 0x50, 0xd1, 0x5e, 0x99, 0x5b, 0x7d, 0x77, 0xcb, 0xc1, 0x92, 0xab, 0xcc, 0xd0, + 0xe2, 0x1a, 0x54, 0x60, 0x05, 0xb8, 0x61, 0x29, 0xae, 0x41, 0x61, 0xca, 0x8e, 0x19, 0xfb, 0x89, + 0x32, 0xc7, 0x09, 0xdb, 0x25, 0x2b, 0x13, 0x91, 0x3b, 0x20, 0x0c, 0xce, 0x04, 0xa1, 0x8d, 0x55, + 0xec, 0xa4, 0xe0, 0x91, 0x09, 0x3a, 0xb2, 0x9c, 0x0c, 0x19, 0x8d, 0x7e, 0x9c, 0xed, 0xab, 0xc1, + 0x13, 0xd8, 0xf5, 0x00, 0xe3, 0xe3, 0x00, 0xf0, 0x2a, 0x4f, 0x3a, 0xea, 0x30, 0x56, 0x6c, 0xd2, + 0x9a, 0x41, 0x47, 0x2b, 0x8e, 0x4e, 0xc7, 0x6c, 0x03, 0x3d, 0xe4, 0xc5, 0x7e, 0x8c, 0xc1, 0x44, + 0xad, 0x11, 0x33, 0xdc, 0x04, 0x07, 0x27, 0x86, 0xf7, 0x55, 0x94, 0xb8, 0x66, 0xdc, 0x07, 0x0a, + 0x37, 0x44, 0xb3, 0xd9, 0xec, 0xf6, 0xa2, 0x81, 0x71, 0x23, 0xd9, 0x1f, 0xf2, 0xdf, 0x9c, 0xf0, + 0x99, 0x73, 0x47, 0xea, 0xc3, 0x80, 0xb5, 0x15, 0x72, 0x3c, 0xbb, 0x78, 0x6b, 0x0b, 0x74, 0x74, + 0x8c, 0xd5, 0x98, 0x4e, 0x30, 0x0e, 0x2c, 0xe5, 0x85, 0xe5, 0x90, 0xd2, 0xf0, 0x5d, 0x3f, 0x18, + 0x07, 0xd9, 0x0c, 0x99, 0x82, 0xe3, 0x49, 0x5e, 0xce, 0x92, 0xe9, 0x4e, 0xc0, 0x58, 0xfc, 0xa6, + 0x00, 0xb6, 0x60, 0x13, 0x1d, 0xb2, 0xf0, 0xae, 0xcf, 0x85, 0x1c, 0x65, 0x78, 0x1b, 0xd9, 0xa5, + 0x31, 0xce, 0x46, 0x3c, 0x2e, 0x14, 0x6d, 0x23, 0xfc, 0x9a, 0x92, 0xdb, 0x8b, 0x47, 0x85, 0xf3, + 0x17, 0xc5, 0xee, 0x57, 0x4d, 0x40, 0x16, 0x92, 0xd9, 0x2c, 0x7e, 0x42, 0x1e, 0x73, 0xbb, 0x0e, + 0x3e, 0xc5, 0x9a, 0x57, 0x1c, 0x76, 0x35, 0x39, 0x20, 0xbe, 0x6a, 0xfa, 0x41, 0xcf, 0x97, 0x0f, + 0xf1, 0x8e, 0x2d, 0x4f, 0x0a, 0xce, 0xd3, 0x65, 0x56, 0xa7, 0xcf, 0x70, 0x68, 0x5f, 0x5c, 0xd7, + 0x51, 0x8b, 0xd3, 0xb3, 0xb5, 0x1f, 0x02, 0x53, 0x38, 0x4c, 0xd2, 0x7c, 0x08, 0x91, 0xcb, 0x45, + 0xdf, 0x76, 0xb6, 0x1c, 0x36, 0x16, 0x59, 0x28, 0xc5, 0xb8, 0xc6, 0xec, 0xca, 0x45, 0xf2, 0x0e, + 0xdf, 0x30, 0x41, 0xee, 0x2b, 0xc6, 0x6e, 0x2e, 0x36, 0x5b, 0xcd, 0xb5, 0xe5, 0xf9, 0x95, 0xe5, + 0x67, 0x35, 0xcd, 0x0b, 0x6b, 0x97, 0x2f, 0x9a, 0xad, 0xf5, 0xb5, 0xe5, 0x4b, 0x4b, 0xe6, 0xe5, + 0x4b, 0x2b, 0x3f, 0xf8, 0x7f, 0xd8, 0x9a, 0x97, 0xd1, 0x3c, 0xa7, 0x9b, 0x0e, 0xa7, 0x41, 0xd6, + 0xa6, 0x83, 0x46, 0xc4, 0x94, 0xd2, 0x26, 0xc4, 0xe0, 0x05, 0x79, 0x57, 0x93, 0x76, 0x3d, 0x8d, + 0x41, 0x08, 0xbe, 0x44, 0xc4, 0xf0, 0xb2, 0x60, 0xca, 0x9f, 0x41, 0x92, 0x5e, 0x29, 0x3b, 0x7d, + 0x0d, 0x4d, 0x47, 0x43, 0xb8, 0xb8, 0x58, 0x14, 0x1b, 0x39, 0x57, 0x81, 0xe9, 0xaf, 0xd3, 0x7e, + 0xd8, 0x09, 0xc1, 0xf2, 0x85, 0xe3, 0x28, 0x61, 0x8d, 0x1c, 0x51, 0xac, 0x6c, 0x8b, 0x1b, 0x40, + 0xd4, 0x00, 0x21, 0x87, 0xa2, 0xb4, 0xda, 0x05, 0x4b, 0x8c, 0x05, 0xe5, 0x70, 0xdb, 0xef, 0x99, + 0x4b, 0xc2, 0x9c, 0x2f, 0x82, 0xd5, 0x1f, 0xac, 0x61, 0x17, 0x12, 0x88, 0x4b, 0x5c, 0xba, 0x84, + 0x75, 0x56, 0xaf, 0x37, 0xaa, 0x28, 0xc8, 0x2d, 0xb0, 0x8d, 0xc1, 0x67, 0x18, 0x59, 0x41, 0xdc, + 0x9a, 0x05, 0x46, 0x92, 0x8f, 0x41, 0xa4, 0x2f, 0xcf, 0xf5, 0x11, 0x0c, 0xa3, 0xf7, 0xd8, 0x4f, + 0xba, 0xdd, 0x75, 0x72, 0x98, 0x9b, 0xe7, 0x60, 0x60, 0x06, 0x62, 0x4e, 0x96, 0x07, 0xee, 0xab, + 0x8f, 0x87, 0xa1, 0xde, 0x10, 0xcb, 0xd5, 0xc9, 0xb9, 0x67, 0x93, 0x4a, 0xce, 0x30, 0x5e, 0x4f, + 0xbc, 0x59, 0x5a, 0x77, 0x46, 0xf3, 0x80, 0xf4, 0xa7, 0x0f, 0x62, 0x92, 0x10, 0xb3, 0x1f, 0x8a, + 0x1b, 0x9c, 0x42, 0xb6, 0xf4, 0x3d, 0x27, 0x12, 0x01, 0xfa, 0x74, 0xed, 0x16, 0x59, 0x54, 0x65, + 0x1e, 0x0b, 0xd0, 0x9b, 0xf1, 0x06, 0x00, 0x83, 0x94, 0x98, 0xda, 0x94, 0x74, 0xef, 0xc4, 0xb9, + 0xda, 0x33, 0xc9, 0xf5, 0xf2, 0x99, 0x5a, 0x79, 0xef, 0x5a, 0xb0, 0xda, 0x3b, 0x58, 0x9c, 0x69, + 0x81, 0x15, 0x1e, 0xf9, 0xe6, 0x8b, 0x89, 0x01, 0x9a, 0xe9, 0xb8, 0xcd, 0xe4, 0x6e, 0x81, 0x29, + 0x8d, 0x46, 0x44, 0xd7, 0x86, 0xd2, 0xad, 0x91, 0xdb, 0x50, 0xd1, 0x12, 0xd5, 0x9d, 0x82, 0x65, + 0x6a, 0x5b, 0x45, 0xee, 0xb3, 0x9e, 0x1c, 0x4b, 0x9f, 0x05, 0xce, 0x7c, 0xe0, 0x3c, 0x21, 0x90, + 0x10, 0xe0, 0x95, 0x00, 0x6e, 0xa0, 0xf6, 0x20, 0x24, 0x08, 0x3c, 0x52, 0x58, 0xb0, 0x42, 0x46, + 0x3f, 0x59, 0x32, 0x4e, 0x61, 0x56, 0xdc, 0xcc, 0x0b, 0x1e, 0xe8, 0xa7, 0x4a, 0xb0, 0xd3, 0x6c, + 0x3c, 0xcb, 0xdf, 0x24, 0xe8, 0xa7, 0x4b, 0xe0, 0xa3, 0x8e, 0x6a, 0x63, 0x31, 0x59, 0xf4, 0x33, + 0x25, 0xb8, 0x92, 0x43, 0xf1, 0x9c, 0x28, 0x5d, 0xd1, 0xcf, 0x96, 0x8c, 0x27, 0x62, 0x08, 0x23, + 0x06, 0x1f, 0x86, 0x5b, 0xd8, 0x1a, 0xf0, 0x0c, 0xb7, 0xd5, 0xdf, 0x4c, 0x1e, 0x28, 0xe8, 0xe7, + 0x4a, 0xc6, 0xb5, 0x58, 0x07, 0x6c, 0xe6, 0x86, 0x71, 0xf4, 0xf3, 0x25, 0x30, 0x0e, 0x47, 0x62, + 0x24, 0xab, 0x96, 0xe3, 0x71, 0x4a, 0xe9, 0x17, 0x4b, 0xc6, 0x75, 0xe4, 0x64, 0x66, 0x3c, 0xa1, + 0xe8, 0x4b, 0x25, 0xa3, 0x46, 0xae, 0x8d, 0xe7, 0x97, 0x7c, 0xd7, 0x66, 0xde, 0x23, 0xd8, 0x21, + 0xb6, 0xbd, 0x10, 0xf8, 0x96, 0xdd, 0xb6, 0x20, 0x92, 0xfd, 0x72, 0x09, 0xc2, 0xbb, 0x4a, 0x0c, + 0x73, 0xf1, 0xf2, 0xfa, 0xa2, 0xd4, 0x30, 0xfa, 0x95, 0x12, 0x04, 0xea, 0xd7, 0xe4, 0xcc, 0x24, + 0xf8, 0xbf, 0x5a, 0x32, 0x6e, 0xc1, 0x7c, 0xb5, 0x19, 0xd7, 0xed, 0xc5, 0xc3, 0xa8, 0xb4, 0x0f, + 0x8b, 0xcd, 0xd5, 0xb5, 0x66, 0x63, 0x7e, 0xbd, 0xb9, 0x48, 0xbf, 0x56, 0x32, 0xee, 0xc0, 0x88, + 0x3e, 0x17, 0x30, 0x29, 0x11, 0x2b, 0x0b, 0xbe, 0x5e, 0x32, 0x6e, 0xc3, 0x64, 0x3d, 0x59, 0x20, + 0x40, 0xd7, 0x7d, 0xbc, 0x37, 0x1e, 0x0a, 0x2a, 0xc0, 0xdf, 0x18, 0x26, 0x23, 0x06, 0x1e, 0x06, + 0xfc, 0xe6, 0x30, 0x19, 0x2a, 0x60, 0x1e, 0x19, 0xdf, 0x2a, 0x41, 0x18, 0x55, 0x8d, 0x17, 0xe0, + 0x7d, 0xc4, 0xfb, 0xd3, 0x6f, 0x97, 0xc0, 0xe4, 0x9d, 0xca, 0x9b, 0x4a, 0xd8, 0xf3, 0x1d, 0xac, + 0x22, 0xdc, 0x14, 0x83, 0x88, 0x14, 0x43, 0xec, 0x38, 0x4c, 0xd8, 0x77, 0x4b, 0xc6, 0x93, 0xc9, + 0x6d, 0xa3, 0x20, 0xf3, 0x28, 0xfb, 0x9e, 0xb6, 0x7d, 0xa3, 0x1f, 0x46, 0x7e, 0xd7, 0x79, 0x9e, + 0x78, 0x99, 0x66, 0xbb, 0x51, 0x3f, 0x60, 0xf4, 0xf1, 0x92, 0x71, 0x2b, 0x16, 0x31, 0x46, 0x83, + 0x24, 0x94, 0x3e, 0xbf, 0x6c, 0x5c, 0x43, 0x8e, 0xc5, 0xa0, 0x1b, 0xf1, 0x39, 0x84, 0x1c, 0xbc, + 0xa0, 0xac, 0x6a, 0xc9, 0xc6, 0xd0, 0x21, 0x5f, 0x58, 0x56, 0xe5, 0x07, 0xab, 0xf8, 0xb2, 0x37, + 0x80, 0xbe, 0x48, 0x43, 0x9a, 0x66, 0x58, 0xc8, 0x2b, 0xfa, 0x12, 0x0d, 0x69, 0x3a, 0xc9, 0x85, + 0x98, 0xbe, 0xb4, 0xac, 0x0a, 0x76, 0xfa, 0x40, 0x10, 0x93, 0xf4, 0xb2, 0xb2, 0x71, 0x3d, 0x99, + 0xcb, 0x9b, 0x97, 0x54, 0xbd, 0xbc, 0xac, 0xaa, 0x9d, 0x5a, 0xd4, 0x54, 0x99, 0xf8, 0x0a, 0x7d, + 0x9b, 0x90, 0xd9, 0x0d, 0xd7, 0x72, 0xf8, 0x83, 0x1e, 0xbf, 0xe3, 0x57, 0x96, 0x55, 0xbd, 0x6b, + 0xf9, 0x41, 0x24, 0x4e, 0xf6, 0xaa, 0xb2, 0x71, 0x06, 0xab, 0x53, 0x62, 0x1c, 0x0c, 0xfc, 0x15, + 0xdf, 0xbd, 0x02, 0xce, 0x0c, 0x4c, 0x56, 0xb4, 0x82, 0x6f, 0x66, 0xca, 0x1e, 0xaf, 0x2e, 0xa7, + 0xaa, 0x0d, 0x7b, 0xf4, 0x6c, 0xd9, 0xbf, 0xd5, 0x02, 0x1b, 0xd0, 0xb5, 0xe8, 0xcf, 0x97, 0x55, + 0x25, 0x13, 0x7c, 0x10, 0x57, 0x15, 0x5f, 0xe3, 0x6b, 0xca, 0x59, 0x29, 0xd2, 0x20, 0x92, 0x43, + 0xff, 0xa2, 0xb6, 0x95, 0x80, 0xbc, 0x68, 0xed, 0xb0, 0x20, 0xbc, 0x68, 0x05, 0x3b, 0xf4, 0x97, + 0xca, 0xc6, 0x93, 0xc8, 0x0d, 0xa3, 0xa6, 0x13, 0x2c, 0xbf, 0x8c, 0x15, 0xad, 0xeb, 0x74, 0xb0, + 0x0d, 0xcf, 0x01, 0xc6, 0x73, 0x73, 0xb7, 0x8c, 0x41, 0x3c, 0xfd, 0x95, 0xb2, 0xaa, 0x9f, 0xf9, + 0x40, 0x09, 0xc6, 0x5f, 0xd5, 0x04, 0xa1, 0x65, 0xed, 0xee, 0x0e, 0x52, 0xfb, 0xf3, 0x6b, 0x65, + 0x55, 0x90, 0x13, 0x8f, 0x03, 0xbc, 0xbe, 0xe0, 0x78, 0x4e, 0xb8, 0x0d, 0xf9, 0xe4, 0x6b, 0xb5, + 0xcb, 0x1c, 0x51, 0x87, 0xa7, 0xbf, 0xae, 0x09, 0x62, 0x03, 0x9b, 0x54, 0xda, 0xc2, 0x4c, 0xbe, + 0x4e, 0xe3, 0x0b, 0x4f, 0xf2, 0xdb, 0x3b, 0x9e, 0x7f, 0x15, 0x12, 0xa3, 0x0e, 0xa0, 0x7f, 0x7d, + 0x59, 0xd5, 0x93, 0x55, 0xf0, 0x8c, 0x2c, 0x0a, 0xcd, 0x16, 0xc3, 0xf5, 0xe2, 0xd7, 0x05, 0x3f, + 0x68, 0x60, 0x57, 0x05, 0x7d, 0x83, 0x46, 0x49, 0x0a, 0xaa, 0x3b, 0x8e, 0x37, 0x96, 0x8d, 0x3a, + 0xb9, 0x75, 0x1c, 0x84, 0x6b, 0xac, 0xe7, 0x0e, 0xe8, 0x9b, 0x94, 0x8b, 0x19, 0x9d, 0xc4, 0xd3, + 0xdf, 0xd6, 0x2e, 0x86, 0xf7, 0xbe, 0x37, 0x92, 0x22, 0xb6, 0x48, 0x66, 0x42, 0xfa, 0x66, 0x4d, + 0x9e, 0x94, 0xf9, 0xdd, 0x6d, 0x0b, 0xd8, 0x06, 0xc7, 0xfd, 0x1d, 0x4d, 0xe8, 0x5b, 0xdb, 0x3e, + 0x7f, 0x9e, 0x0d, 0x57, 0x1d, 0x2c, 0x67, 0x6e, 0xf4, 0xe8, 0xef, 0x96, 0x8d, 0x9b, 0xc9, 0x8d, + 0x09, 0x06, 0x4e, 0xcf, 0xa2, 0x13, 0xf6, 0x5c, 0x6b, 0x70, 0xc9, 0x8f, 0x20, 0x60, 0x6d, 0xf3, + 0x50, 0x9e, 0xfe, 0x9e, 0xc6, 0x55, 0x4e, 0x8e, 0x4c, 0x4e, 0xb0, 0x7d, 0x80, 0xbe, 0x45, 0x13, + 0x5b, 0x73, 0xd9, 0x6b, 0x07, 0x0c, 0xbb, 0xc3, 0x1f, 0x84, 0x84, 0x94, 0x47, 0x3c, 0xc9, 0xb9, + 0x7e, 0x5f, 0x23, 0x99, 0x23, 0x5a, 0x65, 0x9e, 0x07, 0xf1, 0x87, 0xec, 0x98, 0xa3, 0x7f, 0xa0, + 0x6d, 0x35, 0xc4, 0xee, 0x90, 0xfe, 0xa1, 0x76, 0x81, 0xc3, 0xd3, 0x26, 0xf6, 0x08, 0xae, 0x60, + 0x7f, 0x15, 0x1c, 0xfe, 0x9d, 0x9a, 0xd9, 0xe1, 0x7b, 0x35, 0x3b, 0x9d, 0x26, 0x44, 0xe9, 0x5e, + 0x9b, 0xd1, 0x3f, 0xd2, 0x38, 0x8c, 0x17, 0x90, 0x4e, 0x26, 0xe4, 0xfe, 0xb1, 0xa6, 0xfc, 0x17, + 0x44, 0x8a, 0x9d, 0x5f, 0x2e, 0xa0, 0x7f, 0x52, 0x36, 0xce, 0x91, 0xb3, 0x63, 0xc1, 0x26, 0xf8, + 0xff, 0x54, 0x93, 0x31, 0xc1, 0x7f, 0x69, 0xf7, 0x50, 0x4f, 0x59, 0x84, 0x7d, 0x15, 0xf4, 0xcf, + 0xca, 0xc6, 0xed, 0xe4, 0x96, 0x3d, 0xa0, 0x12, 0x9c, 0x7f, 0xae, 0xe9, 0x46, 0x73, 0x17, 0xee, + 0xa9, 0x1d, 0x2d, 0xa1, 0x29, 0xfb, 0x0b, 0xcd, 0xc4, 0x25, 0x2e, 0x91, 0xfe, 0xa5, 0xce, 0x28, + 0xdd, 0x63, 0xd3, 0xbf, 0x1a, 0xd2, 0xc8, 0x5c, 0x7f, 0x4e, 0xdf, 0xae, 0x49, 0x5a, 0x82, 0x3b, + 0x99, 0x7f, 0x87, 0xa6, 0xfa, 0x6b, 0xa8, 0x18, 0x52, 0x82, 0x96, 0xb0, 0xab, 0x02, 0x64, 0x84, + 0xfe, 0xb5, 0x86, 0x22, 0xd3, 0x03, 0x4b, 0x1f, 0xd3, 0x84, 0x75, 0x64, 0x8f, 0x2c, 0xfd, 0x1b, + 0x4d, 0xc6, 0x14, 0x06, 0x24, 0x10, 0x7f, 0xab, 0x09, 0x51, 0x1e, 0x31, 0x09, 0xe8, 0xdf, 0x69, + 0x74, 0x6b, 0x8d, 0x51, 0xb1, 0x83, 0x7a, 0xb7, 0xc6, 0x70, 0xa5, 0xa3, 0x81, 0xbe, 0xa7, 0xac, + 0xc6, 0x64, 0xa9, 0xe3, 0x43, 0x80, 0x8b, 0xa2, 0xdf, 0x80, 0xbe, 0x57, 0x13, 0xb1, 0x5c, 0x98, + 0x84, 0x98, 0xf7, 0x0d, 0x71, 0x40, 0x85, 0x65, 0x81, 0x0c, 0x9f, 0x97, 0x6d, 0xfa, 0xcf, 0x9a, + 0x51, 0x1a, 0x09, 0x97, 0xe0, 0x7d, 0x7f, 0x39, 0x8d, 0x95, 0xf2, 0x4a, 0xcb, 0x72, 0x5d, 0x52, + 0xd0, 0xa2, 0x1f, 0x50, 0x94, 0x27, 0x6f, 0x01, 0x77, 0xfb, 0x1f, 0x54, 0x4e, 0x96, 0x07, 0xb4, + 0x98, 0x76, 0xed, 0xd0, 0x7f, 0x29, 0xa7, 0x41, 0xd1, 0x58, 0xc5, 0x6d, 0xfa, 0xaf, 0x1a, 0xd7, + 0xb1, 0xff, 0x00, 0x9c, 0x32, 0x8f, 0xf4, 0x3f, 0x3c, 0xa3, 0xde, 0xae, 0x9c, 0x31, 0x87, 0x3a, + 0x15, 0xc4, 0xd5, 0x7d, 0x64, 0x46, 0x65, 0xfe, 0x08, 0x50, 0xb9, 0xe1, 0x47, 0x67, 0x54, 0x49, + 0x88, 0x61, 0x5b, 0x98, 0x72, 0xca, 0x56, 0x7f, 0xfa, 0x1f, 0x33, 0xea, 0x7d, 0x27, 0x20, 0x62, + 0xb6, 0xe1, 0xfa, 0xd8, 0xba, 0xf3, 0xb1, 0x19, 0xe3, 0x4e, 0x72, 0xfb, 0x38, 0xd4, 0x25, 0x3b, + 0x7f, 0x7a, 0x46, 0xb7, 0x79, 0x28, 0x83, 0xe0, 0x54, 0xaf, 0x86, 0x2c, 0x30, 0x2f, 0x58, 0x57, + 0xfc, 0x00, 0xcc, 0x9d, 0x18, 0xa5, 0x6f, 0x3f, 0xa8, 0x1e, 0x48, 0x07, 0x5d, 0x70, 0xc1, 0xd9, + 0x62, 0xd1, 0x50, 0xc2, 0xbe, 0xe3, 0xa0, 0xe6, 0x1c, 0xe4, 0x77, 0x0a, 0x5e, 0x04, 0x19, 0x3e, + 0xe7, 0xe3, 0x6f, 0xcc, 0xaa, 0x16, 0x92, 0xdb, 0x59, 0xc8, 0x41, 0x1d, 0x76, 0x95, 0x37, 0xf7, + 0x8a, 0x86, 0x5e, 0xfa, 0xba, 0x59, 0x55, 0x24, 0x15, 0x20, 0xbd, 0xe1, 0x97, 0xbe, 0x7e, 0x56, + 0x8d, 0xe2, 0x14, 0xb8, 0xf8, 0x2a, 0xde, 0x30, 0xab, 0x06, 0xf6, 0x59, 0x80, 0x04, 0xd3, 0x1b, + 0x67, 0x55, 0xb2, 0x15, 0xc0, 0x26, 0x7e, 0x03, 0xc2, 0xe8, 0x6f, 0xce, 0xaa, 0x2c, 0xc8, 0xcc, + 0x6b, 0x7e, 0xed, 0xb7, 0x66, 0x55, 0x45, 0x51, 0x60, 0xf1, 0xcf, 0x05, 0xbf, 0xdf, 0xd9, 0x8e, + 0x34, 0xf8, 0x37, 0x69, 0xa7, 0x58, 0x64, 0x57, 0x4c, 0xbd, 0xe3, 0x89, 0xbe, 0xf7, 0xb0, 0x7a, + 0x8a, 0x2c, 0x40, 0xaa, 0xca, 0x87, 0x35, 0x37, 0x87, 0xdd, 0x0d, 0xf2, 0xcb, 0x02, 0x6e, 0xf2, + 0x1f, 0xab, 0xa8, 0xf1, 0xdb, 0xf0, 0x74, 0x6a, 0xea, 0x2a, 0xaa, 0xc0, 0x71, 0xb0, 0xf8, 0xab, + 0xa4, 0xf8, 0xbb, 0x29, 0xfa, 0xce, 0x8a, 0x26, 0x12, 0x79, 0x30, 0x09, 0xbe, 0xbf, 0xaf, 0xa8, + 0xa6, 0x53, 0x83, 0x6d, 0x60, 0xfb, 0xa4, 0x4b, 0xdf, 0x55, 0x51, 0x5d, 0x7d, 0x0e, 0x44, 0x82, + 0xeb, 0x1f, 0x2a, 0x9a, 0x78, 0xa9, 0x90, 0x28, 0xed, 0xf4, 0x9f, 0x2a, 0xaa, 0xe4, 0x64, 0xe6, + 0x13, 0x3c, 0xef, 0xd6, 0xce, 0xb8, 0x60, 0x79, 0x1e, 0xb3, 0x1f, 0xf1, 0x03, 0x1b, 0x83, 0xef, + 0x98, 0xed, 0xef, 0xa9, 0xa8, 0xa2, 0x3a, 0x0c, 0x23, 0x11, 0xbd, 0x57, 0x23, 0x1d, 0xed, 0x8b, + 0x0e, 0x98, 0xc6, 0xa9, 0xef, 0xd3, 0x48, 0xcb, 0x42, 0x8a, 0xc8, 0x1e, 0xec, 0xac, 0x76, 0x44, + 0x84, 0x5b, 0x74, 0x82, 0x68, 0xd0, 0x5a, 0x14, 0xed, 0x34, 0xf4, 0xfd, 0x19, 0x3c, 0x7c, 0x3e, + 0xfe, 0xa8, 0x25, 0x81, 0xfb, 0x80, 0x76, 0x44, 0xfe, 0x42, 0xc9, 0x77, 0x68, 0x3d, 0xb4, 0xf2, + 0x20, 0x1b, 0x3c, 0x8c, 0x25, 0x33, 0xfa, 0xc1, 0x2c, 0xf5, 0x31, 0xbd, 0x18, 0xf9, 0xf9, 0x2e, + 0x86, 0x17, 0x5d, 0xcb, 0xb3, 0xe9, 0xbf, 0x55, 0xb2, 0x2e, 0xeb, 0x61, 0xd1, 0x88, 0x12, 0x13, + 0xfe, 0xa1, 0x8a, 0x1a, 0xa5, 0xeb, 0x9f, 0x56, 0xd2, 0x7f, 0xd7, 0x64, 0x8f, 0xf7, 0xbe, 0xb1, + 0xcd, 0xf9, 0xd5, 0x65, 0xe9, 0x37, 0x1a, 0xdb, 0xe8, 0x28, 0x6d, 0xfa, 0x61, 0x6d, 0x1b, 0x61, + 0xb4, 0x87, 0xb6, 0xf9, 0xcf, 0x8a, 0x9a, 0x39, 0x14, 0x7f, 0xd7, 0x47, 0xff, 0xab, 0x62, 0x9c, + 0x27, 0xf5, 0xf1, 0x80, 0x93, 0x3b, 0xfd, 0xef, 0x8a, 0x6a, 0x1a, 0x8b, 0xbe, 0xd2, 0xa3, 0x1f, + 0xab, 0xa8, 0x86, 0x77, 0x9c, 0x0f, 0xfa, 0xe8, 0xc7, 0x2b, 0xaa, 0x79, 0xe0, 0xdf, 0x8a, 0x15, + 0x7c, 0x71, 0x19, 0xd2, 0x4f, 0x54, 0x74, 0x7f, 0x9f, 0xf3, 0x35, 0x1b, 0xfd, 0x64, 0x45, 0xf7, + 0xf7, 0x05, 0x9f, 0xdc, 0xd1, 0x4f, 0x55, 0xd4, 0x90, 0x72, 0xac, 0xaf, 0xe3, 0xe8, 0xa7, 0x2b, + 0x6a, 0x30, 0x37, 0xf4, 0xe1, 0x1b, 0xfd, 0x4c, 0x45, 0x35, 0x3b, 0xc3, 0x5f, 0xbf, 0xd1, 0xcf, + 0x66, 0xae, 0x3e, 0xef, 0x63, 0x36, 0xfa, 0xb9, 0x8a, 0x71, 0x16, 0xdb, 0xb9, 0x9a, 0x63, 0x7d, + 0xf3, 0x46, 0x3f, 0x3f, 0x1a, 0xab, 0xf2, 0x45, 0x1a, 0xfd, 0x9f, 0xd1, 0x58, 0x73, 0x3e, 0x5c, + 0xa3, 0x5f, 0xd0, 0x6c, 0x55, 0xce, 0xa7, 0x59, 0xf4, 0x8b, 0x19, 0x95, 0x19, 0xf1, 0xf1, 0x16, + 0xfd, 0x52, 0x45, 0x8d, 0x71, 0x47, 0x7c, 0x0b, 0x45, 0xbf, 0xac, 0xa8, 0x7b, 0xce, 0x67, 0x49, + 0xf4, 0x2b, 0x15, 0xd5, 0x3b, 0x64, 0x3f, 0xc9, 0xa1, 0x5f, 0xcd, 0xd8, 0x03, 0xae, 0x7a, 0x2b, + 0x7e, 0x1b, 0xa5, 0x9b, 0xbb, 0x98, 0x45, 0x67, 0x6b, 0x8b, 0x7e, 0x2d, 0x23, 0x77, 0xb9, 0x70, + 0x09, 0xf9, 0x5f, 0xcf, 0x1c, 0x74, 0xc4, 0xf7, 0x37, 0xf4, 0x1b, 0x15, 0xb5, 0xf8, 0x34, 0xc6, + 0x97, 0x3a, 0xf4, 0x9b, 0x59, 0x26, 0xe6, 0x7f, 0x1f, 0x42, 0xbf, 0xa5, 0x69, 0x7b, 0xf1, 0x87, + 0x14, 0xf4, 0xdb, 0x8a, 0xaa, 0x8c, 0xf8, 0x5e, 0x8a, 0x7e, 0x47, 0x53, 0xa7, 0xdc, 0x6f, 0x07, + 0xe8, 0x77, 0x35, 0xcb, 0x9f, 0xff, 0x01, 0x01, 0xfd, 0x9e, 0xc6, 0xcf, 0x3d, 0xfb, 0xf4, 0xe9, + 0xe3, 0x15, 0xb5, 0x76, 0xb8, 0x77, 0xd3, 0x3d, 0x7d, 0x7e, 0x55, 0x0d, 0x46, 0x45, 0x37, 0xbb, + 0x28, 0x22, 0xbf, 0xa0, 0x6a, 0x1c, 0x27, 0x46, 0xaa, 0xc2, 0x71, 0x13, 0x39, 0x7d, 0x61, 0x55, + 0x15, 0x96, 0x6c, 0x77, 0x39, 0x7d, 0x51, 0x75, 0x98, 0xf1, 0xc8, 0x41, 0x91, 0xe5, 0xf3, 0xa0, + 0x39, 0xee, 0xbd, 0xa7, 0x3f, 0x52, 0x4d, 0x83, 0x8e, 0xa2, 0x86, 0x65, 0xfa, 0xe2, 0x6a, 0x5e, + 0x9c, 0x3f, 0xba, 0xb3, 0x99, 0xbe, 0xa4, 0x9a, 0x9a, 0xd7, 0xe2, 0xae, 0x58, 0xfa, 0xd2, 0xaa, + 0x2e, 0xb3, 0x7b, 0xb4, 0x6d, 0xd2, 0x1f, 0x55, 0xce, 0x9f, 0xd7, 0x4f, 0x49, 0x7f, 0x2c, 0xf7, + 0x54, 0xd9, 0x86, 0x4b, 0xfa, 0xe3, 0xd5, 0x54, 0x79, 0x47, 0x76, 0xe3, 0xd1, 0x9f, 0xa8, 0xa6, + 0x49, 0xf4, 0x9e, 0x3d, 0x7b, 0xf4, 0x27, 0xab, 0xa9, 0x2d, 0xda, 0xbb, 0xed, 0x8a, 0xbe, 0xac, + 0x9a, 0xda, 0xa2, 0xdc, 0x36, 0x23, 0xfa, 0x72, 0xe5, 0x36, 0x0b, 0x1b, 0x91, 0xe8, 0x2b, 0xaa, + 0xa9, 0x5f, 0xcd, 0xe7, 0x39, 0x7d, 0x65, 0x2e, 0x88, 0x5a, 0xf9, 0xa4, 0xaf, 0xca, 0xbd, 0xb9, + 0xbc, 0x8e, 0x4f, 0xfa, 0xea, 0xaa, 0xfa, 0xce, 0xa1, 0x3d, 0x1f, 0xd1, 0x9f, 0xaa, 0xa6, 0x16, + 0xab, 0xe0, 0xbd, 0x88, 0xfe, 0xb4, 0x02, 0x57, 0xf0, 0xac, 0x43, 0x7f, 0x46, 0x91, 0x92, 0x31, + 0x9e, 0x7f, 0xe8, 0xcf, 0x56, 0xcf, 0xbc, 0x66, 0x92, 0x1c, 0xd2, 0x1b, 0xbd, 0x8c, 0x63, 0x24, + 0xa7, 0xf9, 0x8b, 0x3e, 0x01, 0x8e, 0x71, 0x6c, 0x78, 0x7c, 0x91, 0x79, 0x0e, 0x6f, 0x53, 0xe1, + 0x5d, 0x8f, 0xfa, 0x9c, 0xf0, 0x2b, 0xa2, 0x6b, 0x6f, 0x52, 0xf4, 0x4c, 0xea, 0x00, 0xeb, 0x4e, + 0x97, 0xf9, 0x7d, 0x6c, 0x64, 0xcc, 0x99, 0x4c, 0xbb, 0xa0, 0x73, 0x26, 0x2f, 0xf9, 0x17, 0xad, + 0xa8, 0xbd, 0x4d, 0xa7, 0x45, 0xff, 0x93, 0x3e, 0xb9, 0xe1, 0x61, 0x45, 0xd2, 0x13, 0x1b, 0xef, + 0xcf, 0xa3, 0x0c, 0x92, 0x8e, 0x15, 0xbf, 0x03, 0x51, 0xd6, 0x65, 0x8f, 0x96, 0xd4, 0x63, 0x89, + 0xa6, 0x98, 0xb8, 0xbf, 0x9b, 0x96, 0xcf, 0x7c, 0x79, 0x92, 0x5c, 0xdf, 0xd4, 0x82, 0x99, 0xe4, + 0x05, 0x21, 0x0e, 0x9a, 0x44, 0x83, 0x55, 0x31, 0x8c, 0xd6, 0xe8, 0xf3, 0x14, 0x72, 0x6e, 0x4f, + 0xf8, 0xb8, 0x85, 0xc7, 0x6b, 0x4b, 0x8d, 0x06, 0x16, 0x3f, 0x40, 0xee, 0x1b, 0x7b, 0x1d, 0x6a, + 0x30, 0x9c, 0x72, 0xd9, 0x4b, 0x60, 0xe1, 0x0a, 0x9e, 0x41, 0x9e, 0x36, 0x2e, 0x02, 0x88, 0xbd, + 0x5c, 0x1b, 0xbf, 0x96, 0x71, 0x3c, 0xe9, 0x7e, 0x64, 0x77, 0xd7, 0x78, 0xcb, 0x2f, 0xf9, 0xb1, + 0x4f, 0xde, 0x07, 0x51, 0xe1, 0xd9, 0x3d, 0x97, 0xc5, 0xd2, 0x7e, 0xa1, 0xef, 0xba, 0x74, 0xfa, + 0xcc, 0x27, 0x26, 0xc9, 0xb5, 0x23, 0xb8, 0x2e, 0x42, 0x49, 0xd1, 0xee, 0x5e, 0x04, 0xa1, 0x71, + 0xfc, 0xe9, 0xe4, 0x9e, 0x3d, 0xa0, 0x15, 0xbe, 0x0d, 0xb1, 0x6d, 0xc2, 0xb8, 0x97, 0x3c, 0x65, + 0xbc, 0xd5, 0xc3, 0x4c, 0x03, 0x96, 0x9f, 0x27, 0x77, 0x8c, 0xb7, 0x36, 0xe5, 0xd8, 0x14, 0x04, + 0xa5, 0xf5, 0x71, 0x17, 0x2d, 0xb2, 0x08, 0xfe, 0x04, 0x2e, 0x17, 0x5c, 0xce, 0xd0, 0x1a, 0xb6, + 0xeb, 0x7b, 0x22, 0xe3, 0x00, 0x4e, 0xbf, 0x76, 0x82, 0x9c, 0x1c, 0xf9, 0x01, 0x9b, 0xf8, 0x0a, + 0x2a, 0xf3, 0x09, 0x5b, 0xa2, 0xed, 0xfa, 0xc4, 0x82, 0x65, 0xc7, 0xd1, 0xc7, 0x24, 0x04, 0x72, + 0x73, 0x19, 0x00, 0xd4, 0x3a, 0xc7, 0xdb, 0xe1, 0x9d, 0x82, 0xb7, 0x71, 0x5f, 0xa1, 0xcf, 0x6f, + 0x80, 0xeb, 0xed, 0xf5, 0xfc, 0x00, 0xdc, 0x97, 0x9c, 0x58, 0x1f, 0xf4, 0x40, 0x82, 0xce, 0xfc, + 0xe3, 0x01, 0x72, 0x4d, 0xc1, 0xf7, 0x30, 0xa2, 0x17, 0x79, 0x9c, 0x0f, 0x66, 0x40, 0x14, 0xf6, + 0x84, 0x5d, 0x64, 0x6d, 0xfc, 0x88, 0x10, 0x6d, 0x1a, 0x57, 0xd4, 0x22, 0xd8, 0x87, 0xe7, 0x1b, + 0xa6, 0x48, 0x5d, 0xe3, 0x0a, 0x13, 0x37, 0x75, 0xfc, 0xd2, 0xc7, 0x5c, 0xb7, 0xce, 0xbf, 0x3c, + 0x05, 0x8e, 0xdc, 0x43, 0xee, 0x2a, 0x5e, 0x24, 0x20, 0xe3, 0xa6, 0x69, 0x53, 0x96, 0xb6, 0xe0, + 0xea, 0xf7, 0x3e, 0x92, 0x13, 0xe2, 0xbb, 0x85, 0x0d, 0xe6, 0xf2, 0x2c, 0xf7, 0x0e, 0x05, 0xb0, + 0x89, 0x69, 0x5c, 0xf6, 0xc0, 0x76, 0xf2, 0xce, 0xed, 0x22, 0x70, 0x59, 0xb6, 0x28, 0x89, 0x16, + 0xf3, 0x42, 0xf2, 0x7d, 0xbf, 0xe5, 0xfb, 0x1e, 0xc5, 0x4a, 0xe4, 0xed, 0x63, 0x81, 0xae, 0x32, + 0xb0, 0x0e, 0xd1, 0x80, 0x1e, 0x18, 0x83, 0x37, 0xfc, 0x33, 0xab, 0xcc, 0x55, 0x10, 0xa1, 0x16, + 0x63, 0xaf, 0x94, 0x97, 0x31, 0x63, 0x34, 0xc8, 0x03, 0xc5, 0xcb, 0x2e, 0x04, 0x8c, 0x8b, 0x15, + 0xef, 0x92, 0x48, 0x36, 0x54, 0x1f, 0x2b, 0x0f, 0x0a, 0xbb, 0x51, 0x84, 0xa4, 0x05, 0x01, 0x2f, + 0x76, 0xc5, 0x0e, 0xa3, 0xa1, 0xb3, 0x7b, 0xd3, 0x8d, 0xce, 0xd5, 0x69, 0x33, 0xfc, 0xbc, 0xe7, + 0x0a, 0x28, 0x36, 0xde, 0x2f, 0x3d, 0x34, 0x06, 0x6b, 0x85, 0x10, 0x2d, 0xc8, 0x8e, 0xfb, 0xc3, + 0x7b, 0xcb, 0xea, 0x25, 0x30, 0xa2, 0xbc, 0xd7, 0x02, 0xfc, 0x7c, 0xb3, 0x8b, 0xc6, 0x86, 0xee, + 0xbd, 0x0d, 0x2e, 0x6a, 0x61, 0x07, 0xda, 0x52, 0xdf, 0x0a, 0x6c, 0x7a, 0xc4, 0xb8, 0x8b, 0x3c, + 0x79, 0x8f, 0xf3, 0x24, 0xd0, 0x8b, 0xf2, 0x1f, 0x83, 0xa0, 0x86, 0x70, 0x1d, 0x85, 0xc7, 0xd9, + 0x66, 0x03, 0xd1, 0x86, 0xcc, 0xc7, 0x69, 0xc5, 0x78, 0x2a, 0x39, 0x5f, 0xbc, 0x04, 0xf2, 0x0c, + 0xfc, 0x27, 0x98, 0x56, 0xad, 0x30, 0xbc, 0xea, 0x07, 0xb6, 0xc9, 0x9f, 0x27, 0x68, 0x55, 0x18, + 0xdd, 0xa2, 0x85, 0x1b, 0x21, 0x56, 0x92, 0x2f, 0xb1, 0xab, 0x60, 0x22, 0x90, 0xf5, 0xf4, 0xe8, + 0x38, 0xb7, 0xc4, 0xef, 0x95, 0x47, 0x32, 0xe0, 0x1e, 0xfc, 0x1d, 0x87, 0xd1, 0x63, 0x0b, 0xd3, + 0xcf, 0x9c, 0x78, 0xfe, 0xc4, 0x13, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0x7c, 0x79, 0x06, 0x37, + 0xa6, 0x4b, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/gcsdk.pb.go b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/gcsdk.pb.go new file mode 100644 index 00000000..9e7b5da3 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/gcsdk.pb.go @@ -0,0 +1,1825 @@ +// Code generated by protoc-gen-go. +// source: gcsdk_gcmessages.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 protobuf is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type ESourceEngine int32 + +const ( + ESourceEngine_k_ESE_Source1 ESourceEngine = 0 + ESourceEngine_k_ESE_Source2 ESourceEngine = 1 +) + +var ESourceEngine_name = map[int32]string{ + 0: "k_ESE_Source1", + 1: "k_ESE_Source2", +} +var ESourceEngine_value = map[string]int32{ + "k_ESE_Source1": 0, + "k_ESE_Source2": 1, +} + +func (x ESourceEngine) Enum() *ESourceEngine { + p := new(ESourceEngine) + *p = x + return p +} +func (x ESourceEngine) String() string { + return proto.EnumName(ESourceEngine_name, int32(x)) +} +func (x *ESourceEngine) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ESourceEngine_value, data, "ESourceEngine") + if err != nil { + return err + } + *x = ESourceEngine(value) + return nil +} +func (ESourceEngine) EnumDescriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{0} } + +type PartnerAccountType int32 + +const ( + PartnerAccountType_PARTNER_NONE PartnerAccountType = 0 + PartnerAccountType_PARTNER_PERFECT_WORLD PartnerAccountType = 1 + PartnerAccountType_PARTNER_NEXON PartnerAccountType = 2 + PartnerAccountType_PARTNER_INVALID PartnerAccountType = 3 +) + +var PartnerAccountType_name = map[int32]string{ + 0: "PARTNER_NONE", + 1: "PARTNER_PERFECT_WORLD", + 2: "PARTNER_NEXON", + 3: "PARTNER_INVALID", +} +var PartnerAccountType_value = map[string]int32{ + "PARTNER_NONE": 0, + "PARTNER_PERFECT_WORLD": 1, + "PARTNER_NEXON": 2, + "PARTNER_INVALID": 3, +} + +func (x PartnerAccountType) Enum() *PartnerAccountType { + p := new(PartnerAccountType) + *p = x + return p +} +func (x PartnerAccountType) String() string { + return proto.EnumName(PartnerAccountType_name, int32(x)) +} +func (x *PartnerAccountType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PartnerAccountType_value, data, "PartnerAccountType") + if err != nil { + return err + } + *x = PartnerAccountType(value) + return nil +} +func (PartnerAccountType) EnumDescriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{1} } + +type GCConnectionStatus int32 + +const ( + GCConnectionStatus_GCConnectionStatus_HAVE_SESSION GCConnectionStatus = 0 + GCConnectionStatus_GCConnectionStatus_GC_GOING_DOWN GCConnectionStatus = 1 + GCConnectionStatus_GCConnectionStatus_NO_SESSION GCConnectionStatus = 2 + GCConnectionStatus_GCConnectionStatus_NO_SESSION_IN_LOGON_QUEUE GCConnectionStatus = 3 + GCConnectionStatus_GCConnectionStatus_NO_STEAM GCConnectionStatus = 4 + GCConnectionStatus_GCConnectionStatus_SUSPENDED GCConnectionStatus = 5 + GCConnectionStatus_GCConnectionStatus_STEAM_GOING_DOWN GCConnectionStatus = 6 +) + +var GCConnectionStatus_name = map[int32]string{ + 0: "GCConnectionStatus_HAVE_SESSION", + 1: "GCConnectionStatus_GC_GOING_DOWN", + 2: "GCConnectionStatus_NO_SESSION", + 3: "GCConnectionStatus_NO_SESSION_IN_LOGON_QUEUE", + 4: "GCConnectionStatus_NO_STEAM", + 5: "GCConnectionStatus_SUSPENDED", + 6: "GCConnectionStatus_STEAM_GOING_DOWN", +} +var GCConnectionStatus_value = map[string]int32{ + "GCConnectionStatus_HAVE_SESSION": 0, + "GCConnectionStatus_GC_GOING_DOWN": 1, + "GCConnectionStatus_NO_SESSION": 2, + "GCConnectionStatus_NO_SESSION_IN_LOGON_QUEUE": 3, + "GCConnectionStatus_NO_STEAM": 4, + "GCConnectionStatus_SUSPENDED": 5, + "GCConnectionStatus_STEAM_GOING_DOWN": 6, +} + +func (x GCConnectionStatus) Enum() *GCConnectionStatus { + p := new(GCConnectionStatus) + *p = x + return p +} +func (x GCConnectionStatus) String() string { + return proto.EnumName(GCConnectionStatus_name, int32(x)) +} +func (x *GCConnectionStatus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GCConnectionStatus_value, data, "GCConnectionStatus") + if err != nil { + return err + } + *x = GCConnectionStatus(value) + return nil +} +func (GCConnectionStatus) EnumDescriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{2} } + +type CMsgSHA1Digest struct { + Block1 *uint64 `protobuf:"fixed64,1,req,name=block1" json:"block1,omitempty"` + Block2 *uint64 `protobuf:"fixed64,2,req,name=block2" json:"block2,omitempty"` + Block3 *uint32 `protobuf:"fixed32,3,req,name=block3" json:"block3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSHA1Digest) Reset() { *m = CMsgSHA1Digest{} } +func (m *CMsgSHA1Digest) String() string { return proto.CompactTextString(m) } +func (*CMsgSHA1Digest) ProtoMessage() {} +func (*CMsgSHA1Digest) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{0} } + +func (m *CMsgSHA1Digest) GetBlock1() uint64 { + if m != nil && m.Block1 != nil { + return *m.Block1 + } + return 0 +} + +func (m *CMsgSHA1Digest) GetBlock2() uint64 { + if m != nil && m.Block2 != nil { + return *m.Block2 + } + return 0 +} + +func (m *CMsgSHA1Digest) GetBlock3() uint32 { + if m != nil && m.Block3 != nil { + return *m.Block3 + } + return 0 +} + +type CMsgSOIDOwner struct { + Type *uint32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"` + Id *uint64 `protobuf:"varint,2,opt,name=id" json:"id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOIDOwner) Reset() { *m = CMsgSOIDOwner{} } +func (m *CMsgSOIDOwner) String() string { return proto.CompactTextString(m) } +func (*CMsgSOIDOwner) ProtoMessage() {} +func (*CMsgSOIDOwner) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{1} } + +func (m *CMsgSOIDOwner) GetType() uint32 { + if m != nil && m.Type != nil { + return *m.Type + } + return 0 +} + +func (m *CMsgSOIDOwner) GetId() uint64 { + if m != nil && m.Id != nil { + return *m.Id + } + return 0 +} + +type CMsgSOSingleObject struct { + TypeId *int32 `protobuf:"varint,2,opt,name=type_id" json:"type_id,omitempty"` + ObjectData []byte `protobuf:"bytes,3,opt,name=object_data" json:"object_data,omitempty"` + Version *uint64 `protobuf:"fixed64,4,opt,name=version" json:"version,omitempty"` + OwnerSoid *CMsgSOIDOwner `protobuf:"bytes,5,opt,name=owner_soid" json:"owner_soid,omitempty"` + ServiceId *uint32 `protobuf:"varint,6,opt,name=service_id" json:"service_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOSingleObject) Reset() { *m = CMsgSOSingleObject{} } +func (m *CMsgSOSingleObject) String() string { return proto.CompactTextString(m) } +func (*CMsgSOSingleObject) ProtoMessage() {} +func (*CMsgSOSingleObject) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{2} } + +func (m *CMsgSOSingleObject) GetTypeId() int32 { + if m != nil && m.TypeId != nil { + return *m.TypeId + } + return 0 +} + +func (m *CMsgSOSingleObject) GetObjectData() []byte { + if m != nil { + return m.ObjectData + } + return nil +} + +func (m *CMsgSOSingleObject) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgSOSingleObject) GetOwnerSoid() *CMsgSOIDOwner { + if m != nil { + return m.OwnerSoid + } + return nil +} + +func (m *CMsgSOSingleObject) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +type CMsgSOMultipleObjects struct { + ObjectsModified []*CMsgSOMultipleObjects_SingleObject `protobuf:"bytes,2,rep,name=objects_modified" json:"objects_modified,omitempty"` + Version *uint64 `protobuf:"fixed64,3,opt,name=version" json:"version,omitempty"` + ObjectsAdded []*CMsgSOMultipleObjects_SingleObject `protobuf:"bytes,4,rep,name=objects_added" json:"objects_added,omitempty"` + ObjectsRemoved []*CMsgSOMultipleObjects_SingleObject `protobuf:"bytes,5,rep,name=objects_removed" json:"objects_removed,omitempty"` + OwnerSoid *CMsgSOIDOwner `protobuf:"bytes,6,opt,name=owner_soid" json:"owner_soid,omitempty"` + ServiceId *uint32 `protobuf:"varint,7,opt,name=service_id" json:"service_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOMultipleObjects) Reset() { *m = CMsgSOMultipleObjects{} } +func (m *CMsgSOMultipleObjects) String() string { return proto.CompactTextString(m) } +func (*CMsgSOMultipleObjects) ProtoMessage() {} +func (*CMsgSOMultipleObjects) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{3} } + +func (m *CMsgSOMultipleObjects) GetObjectsModified() []*CMsgSOMultipleObjects_SingleObject { + if m != nil { + return m.ObjectsModified + } + return nil +} + +func (m *CMsgSOMultipleObjects) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgSOMultipleObjects) GetObjectsAdded() []*CMsgSOMultipleObjects_SingleObject { + if m != nil { + return m.ObjectsAdded + } + return nil +} + +func (m *CMsgSOMultipleObjects) GetObjectsRemoved() []*CMsgSOMultipleObjects_SingleObject { + if m != nil { + return m.ObjectsRemoved + } + return nil +} + +func (m *CMsgSOMultipleObjects) GetOwnerSoid() *CMsgSOIDOwner { + if m != nil { + return m.OwnerSoid + } + return nil +} + +func (m *CMsgSOMultipleObjects) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +type CMsgSOMultipleObjects_SingleObject struct { + TypeId *int32 `protobuf:"varint,1,opt,name=type_id" json:"type_id,omitempty"` + ObjectData []byte `protobuf:"bytes,2,opt,name=object_data" json:"object_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOMultipleObjects_SingleObject) Reset() { *m = CMsgSOMultipleObjects_SingleObject{} } +func (m *CMsgSOMultipleObjects_SingleObject) String() string { return proto.CompactTextString(m) } +func (*CMsgSOMultipleObjects_SingleObject) ProtoMessage() {} +func (*CMsgSOMultipleObjects_SingleObject) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{3, 0} +} + +func (m *CMsgSOMultipleObjects_SingleObject) GetTypeId() int32 { + if m != nil && m.TypeId != nil { + return *m.TypeId + } + return 0 +} + +func (m *CMsgSOMultipleObjects_SingleObject) GetObjectData() []byte { + if m != nil { + return m.ObjectData + } + return nil +} + +type CMsgSOCacheSubscribed struct { + Objects []*CMsgSOCacheSubscribed_SubscribedType `protobuf:"bytes,2,rep,name=objects" json:"objects,omitempty"` + Version *uint64 `protobuf:"fixed64,3,opt,name=version" json:"version,omitempty"` + OwnerSoid *CMsgSOIDOwner `protobuf:"bytes,4,opt,name=owner_soid" json:"owner_soid,omitempty"` + ServiceId *uint32 `protobuf:"varint,5,opt,name=service_id" json:"service_id,omitempty"` + ServiceList []uint32 `protobuf:"varint,6,rep,name=service_list" json:"service_list,omitempty"` + SyncVersion *uint64 `protobuf:"fixed64,7,opt,name=sync_version" json:"sync_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheSubscribed) Reset() { *m = CMsgSOCacheSubscribed{} } +func (m *CMsgSOCacheSubscribed) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheSubscribed) ProtoMessage() {} +func (*CMsgSOCacheSubscribed) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{4} } + +func (m *CMsgSOCacheSubscribed) GetObjects() []*CMsgSOCacheSubscribed_SubscribedType { + if m != nil { + return m.Objects + } + return nil +} + +func (m *CMsgSOCacheSubscribed) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgSOCacheSubscribed) GetOwnerSoid() *CMsgSOIDOwner { + if m != nil { + return m.OwnerSoid + } + return nil +} + +func (m *CMsgSOCacheSubscribed) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +func (m *CMsgSOCacheSubscribed) GetServiceList() []uint32 { + if m != nil { + return m.ServiceList + } + return nil +} + +func (m *CMsgSOCacheSubscribed) GetSyncVersion() uint64 { + if m != nil && m.SyncVersion != nil { + return *m.SyncVersion + } + return 0 +} + +type CMsgSOCacheSubscribed_SubscribedType struct { + TypeId *int32 `protobuf:"varint,1,opt,name=type_id" json:"type_id,omitempty"` + ObjectData [][]byte `protobuf:"bytes,2,rep,name=object_data" json:"object_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheSubscribed_SubscribedType) Reset() { *m = CMsgSOCacheSubscribed_SubscribedType{} } +func (m *CMsgSOCacheSubscribed_SubscribedType) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheSubscribed_SubscribedType) ProtoMessage() {} +func (*CMsgSOCacheSubscribed_SubscribedType) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{4, 0} +} + +func (m *CMsgSOCacheSubscribed_SubscribedType) GetTypeId() int32 { + if m != nil && m.TypeId != nil { + return *m.TypeId + } + return 0 +} + +func (m *CMsgSOCacheSubscribed_SubscribedType) GetObjectData() [][]byte { + if m != nil { + return m.ObjectData + } + return nil +} + +type CMsgSOCacheSubscribedUpToDate struct { + Version *uint64 `protobuf:"fixed64,1,opt,name=version" json:"version,omitempty"` + OwnerSoid *CMsgSOIDOwner `protobuf:"bytes,2,opt,name=owner_soid" json:"owner_soid,omitempty"` + ServiceId *uint32 `protobuf:"varint,3,opt,name=service_id" json:"service_id,omitempty"` + ServiceList []uint32 `protobuf:"varint,4,rep,name=service_list" json:"service_list,omitempty"` + SyncVersion *uint64 `protobuf:"fixed64,5,opt,name=sync_version" json:"sync_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheSubscribedUpToDate) Reset() { *m = CMsgSOCacheSubscribedUpToDate{} } +func (m *CMsgSOCacheSubscribedUpToDate) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheSubscribedUpToDate) ProtoMessage() {} +func (*CMsgSOCacheSubscribedUpToDate) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{5} } + +func (m *CMsgSOCacheSubscribedUpToDate) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgSOCacheSubscribedUpToDate) GetOwnerSoid() *CMsgSOIDOwner { + if m != nil { + return m.OwnerSoid + } + return nil +} + +func (m *CMsgSOCacheSubscribedUpToDate) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +func (m *CMsgSOCacheSubscribedUpToDate) GetServiceList() []uint32 { + if m != nil { + return m.ServiceList + } + return nil +} + +func (m *CMsgSOCacheSubscribedUpToDate) GetSyncVersion() uint64 { + if m != nil && m.SyncVersion != nil { + return *m.SyncVersion + } + return 0 +} + +type CMsgSOCacheUnsubscribed struct { + OwnerSoid *CMsgSOIDOwner `protobuf:"bytes,2,opt,name=owner_soid" json:"owner_soid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheUnsubscribed) Reset() { *m = CMsgSOCacheUnsubscribed{} } +func (m *CMsgSOCacheUnsubscribed) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheUnsubscribed) ProtoMessage() {} +func (*CMsgSOCacheUnsubscribed) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{6} } + +func (m *CMsgSOCacheUnsubscribed) GetOwnerSoid() *CMsgSOIDOwner { + if m != nil { + return m.OwnerSoid + } + return nil +} + +type CMsgSOCacheSubscriptionCheck struct { + Version *uint64 `protobuf:"fixed64,2,opt,name=version" json:"version,omitempty"` + OwnerSoid *CMsgSOIDOwner `protobuf:"bytes,3,opt,name=owner_soid" json:"owner_soid,omitempty"` + ServiceId *uint32 `protobuf:"varint,4,opt,name=service_id" json:"service_id,omitempty"` + ServiceList []uint32 `protobuf:"varint,5,rep,name=service_list" json:"service_list,omitempty"` + SyncVersion *uint64 `protobuf:"fixed64,6,opt,name=sync_version" json:"sync_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheSubscriptionCheck) Reset() { *m = CMsgSOCacheSubscriptionCheck{} } +func (m *CMsgSOCacheSubscriptionCheck) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheSubscriptionCheck) ProtoMessage() {} +func (*CMsgSOCacheSubscriptionCheck) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{7} } + +func (m *CMsgSOCacheSubscriptionCheck) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgSOCacheSubscriptionCheck) GetOwnerSoid() *CMsgSOIDOwner { + if m != nil { + return m.OwnerSoid + } + return nil +} + +func (m *CMsgSOCacheSubscriptionCheck) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +func (m *CMsgSOCacheSubscriptionCheck) GetServiceList() []uint32 { + if m != nil { + return m.ServiceList + } + return nil +} + +func (m *CMsgSOCacheSubscriptionCheck) GetSyncVersion() uint64 { + if m != nil && m.SyncVersion != nil { + return *m.SyncVersion + } + return 0 +} + +type CMsgSOCacheSubscriptionRefresh struct { + OwnerSoid *CMsgSOIDOwner `protobuf:"bytes,2,opt,name=owner_soid" json:"owner_soid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheSubscriptionRefresh) Reset() { *m = CMsgSOCacheSubscriptionRefresh{} } +func (m *CMsgSOCacheSubscriptionRefresh) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheSubscriptionRefresh) ProtoMessage() {} +func (*CMsgSOCacheSubscriptionRefresh) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{8} } + +func (m *CMsgSOCacheSubscriptionRefresh) GetOwnerSoid() *CMsgSOIDOwner { + if m != nil { + return m.OwnerSoid + } + return nil +} + +type CMsgSOCacheVersion struct { + Version *uint64 `protobuf:"fixed64,1,opt,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheVersion) Reset() { *m = CMsgSOCacheVersion{} } +func (m *CMsgSOCacheVersion) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheVersion) ProtoMessage() {} +func (*CMsgSOCacheVersion) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{9} } + +func (m *CMsgSOCacheVersion) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +type CMsgGCMultiplexMessage struct { + Msgtype *uint32 `protobuf:"varint,1,opt,name=msgtype" json:"msgtype,omitempty"` + Payload []byte `protobuf:"bytes,2,opt,name=payload" json:"payload,omitempty"` + Steamids []uint64 `protobuf:"fixed64,3,rep,name=steamids" json:"steamids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCMultiplexMessage) Reset() { *m = CMsgGCMultiplexMessage{} } +func (m *CMsgGCMultiplexMessage) String() string { return proto.CompactTextString(m) } +func (*CMsgGCMultiplexMessage) ProtoMessage() {} +func (*CMsgGCMultiplexMessage) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{10} } + +func (m *CMsgGCMultiplexMessage) GetMsgtype() uint32 { + if m != nil && m.Msgtype != nil { + return *m.Msgtype + } + return 0 +} + +func (m *CMsgGCMultiplexMessage) GetPayload() []byte { + if m != nil { + return m.Payload + } + return nil +} + +func (m *CMsgGCMultiplexMessage) GetSteamids() []uint64 { + if m != nil { + return m.Steamids + } + return nil +} + +type CGCToGCMsgMasterAck struct { + DirIndex *uint32 `protobuf:"varint,1,opt,name=dir_index" json:"dir_index,omitempty"` + MachineName *string `protobuf:"bytes,3,opt,name=machine_name" json:"machine_name,omitempty"` + ProcessName *string `protobuf:"bytes,4,opt,name=process_name" json:"process_name,omitempty"` + Directory []*CGCToGCMsgMasterAck_Process `protobuf:"bytes,6,rep,name=directory" json:"directory,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCToGCMsgMasterAck) Reset() { *m = CGCToGCMsgMasterAck{} } +func (m *CGCToGCMsgMasterAck) String() string { return proto.CompactTextString(m) } +func (*CGCToGCMsgMasterAck) ProtoMessage() {} +func (*CGCToGCMsgMasterAck) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{11} } + +func (m *CGCToGCMsgMasterAck) GetDirIndex() uint32 { + if m != nil && m.DirIndex != nil { + return *m.DirIndex + } + return 0 +} + +func (m *CGCToGCMsgMasterAck) GetMachineName() string { + if m != nil && m.MachineName != nil { + return *m.MachineName + } + return "" +} + +func (m *CGCToGCMsgMasterAck) GetProcessName() string { + if m != nil && m.ProcessName != nil { + return *m.ProcessName + } + return "" +} + +func (m *CGCToGCMsgMasterAck) GetDirectory() []*CGCToGCMsgMasterAck_Process { + if m != nil { + return m.Directory + } + return nil +} + +type CGCToGCMsgMasterAck_Process struct { + DirIndex *uint32 `protobuf:"varint,1,opt,name=dir_index" json:"dir_index,omitempty"` + TypeInstances []uint32 `protobuf:"varint,2,rep,name=type_instances" json:"type_instances,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCToGCMsgMasterAck_Process) Reset() { *m = CGCToGCMsgMasterAck_Process{} } +func (m *CGCToGCMsgMasterAck_Process) String() string { return proto.CompactTextString(m) } +func (*CGCToGCMsgMasterAck_Process) ProtoMessage() {} +func (*CGCToGCMsgMasterAck_Process) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{11, 0} } + +func (m *CGCToGCMsgMasterAck_Process) GetDirIndex() uint32 { + if m != nil && m.DirIndex != nil { + return *m.DirIndex + } + return 0 +} + +func (m *CGCToGCMsgMasterAck_Process) GetTypeInstances() []uint32 { + if m != nil { + return m.TypeInstances + } + return nil +} + +type CGCToGCMsgMasterAck_Response struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCToGCMsgMasterAck_Response) Reset() { *m = CGCToGCMsgMasterAck_Response{} } +func (m *CGCToGCMsgMasterAck_Response) String() string { return proto.CompactTextString(m) } +func (*CGCToGCMsgMasterAck_Response) ProtoMessage() {} +func (*CGCToGCMsgMasterAck_Response) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{12} } + +const Default_CGCToGCMsgMasterAck_Response_Eresult int32 = 2 + +func (m *CGCToGCMsgMasterAck_Response) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CGCToGCMsgMasterAck_Response_Eresult +} + +type CGCToGCMsgMasterStartupComplete struct { + GcInfo []*CGCToGCMsgMasterStartupComplete_GCInfo `protobuf:"bytes,1,rep,name=gc_info" json:"gc_info,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCToGCMsgMasterStartupComplete) Reset() { *m = CGCToGCMsgMasterStartupComplete{} } +func (m *CGCToGCMsgMasterStartupComplete) String() string { return proto.CompactTextString(m) } +func (*CGCToGCMsgMasterStartupComplete) ProtoMessage() {} +func (*CGCToGCMsgMasterStartupComplete) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{13} +} + +func (m *CGCToGCMsgMasterStartupComplete) GetGcInfo() []*CGCToGCMsgMasterStartupComplete_GCInfo { + if m != nil { + return m.GcInfo + } + return nil +} + +type CGCToGCMsgMasterStartupComplete_GCInfo struct { + DirIndex *uint32 `protobuf:"varint,1,opt,name=dir_index" json:"dir_index,omitempty"` + MachineName *string `protobuf:"bytes,2,opt,name=machine_name" json:"machine_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCToGCMsgMasterStartupComplete_GCInfo) Reset() { + *m = CGCToGCMsgMasterStartupComplete_GCInfo{} +} +func (m *CGCToGCMsgMasterStartupComplete_GCInfo) String() string { return proto.CompactTextString(m) } +func (*CGCToGCMsgMasterStartupComplete_GCInfo) ProtoMessage() {} +func (*CGCToGCMsgMasterStartupComplete_GCInfo) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{13, 0} +} + +func (m *CGCToGCMsgMasterStartupComplete_GCInfo) GetDirIndex() uint32 { + if m != nil && m.DirIndex != nil { + return *m.DirIndex + } + return 0 +} + +func (m *CGCToGCMsgMasterStartupComplete_GCInfo) GetMachineName() string { + if m != nil && m.MachineName != nil { + return *m.MachineName + } + return "" +} + +type CGCToGCMsgRouted struct { + MsgType *uint32 `protobuf:"varint,1,opt,name=msg_type" json:"msg_type,omitempty"` + SenderId *uint64 `protobuf:"fixed64,2,opt,name=sender_id" json:"sender_id,omitempty"` + NetMessage []byte `protobuf:"bytes,3,opt,name=net_message" json:"net_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCToGCMsgRouted) Reset() { *m = CGCToGCMsgRouted{} } +func (m *CGCToGCMsgRouted) String() string { return proto.CompactTextString(m) } +func (*CGCToGCMsgRouted) ProtoMessage() {} +func (*CGCToGCMsgRouted) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{14} } + +func (m *CGCToGCMsgRouted) GetMsgType() uint32 { + if m != nil && m.MsgType != nil { + return *m.MsgType + } + return 0 +} + +func (m *CGCToGCMsgRouted) GetSenderId() uint64 { + if m != nil && m.SenderId != nil { + return *m.SenderId + } + return 0 +} + +func (m *CGCToGCMsgRouted) GetNetMessage() []byte { + if m != nil { + return m.NetMessage + } + return nil +} + +type CGCToGCMsgRoutedReply struct { + MsgType *uint32 `protobuf:"varint,1,opt,name=msg_type" json:"msg_type,omitempty"` + NetMessage []byte `protobuf:"bytes,2,opt,name=net_message" json:"net_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGCToGCMsgRoutedReply) Reset() { *m = CGCToGCMsgRoutedReply{} } +func (m *CGCToGCMsgRoutedReply) String() string { return proto.CompactTextString(m) } +func (*CGCToGCMsgRoutedReply) ProtoMessage() {} +func (*CGCToGCMsgRoutedReply) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{15} } + +func (m *CGCToGCMsgRoutedReply) GetMsgType() uint32 { + if m != nil && m.MsgType != nil { + return *m.MsgType + } + return 0 +} + +func (m *CGCToGCMsgRoutedReply) GetNetMessage() []byte { + if m != nil { + return m.NetMessage + } + return nil +} + +type CMsgGCUpdateSubGCSessionInfo struct { + Updates []*CMsgGCUpdateSubGCSessionInfo_CMsgUpdate `protobuf:"bytes,1,rep,name=updates" json:"updates,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCUpdateSubGCSessionInfo) Reset() { *m = CMsgGCUpdateSubGCSessionInfo{} } +func (m *CMsgGCUpdateSubGCSessionInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgGCUpdateSubGCSessionInfo) ProtoMessage() {} +func (*CMsgGCUpdateSubGCSessionInfo) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{16} } + +func (m *CMsgGCUpdateSubGCSessionInfo) GetUpdates() []*CMsgGCUpdateSubGCSessionInfo_CMsgUpdate { + if m != nil { + return m.Updates + } + return nil +} + +type CMsgGCUpdateSubGCSessionInfo_CMsgUpdate struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Ip *uint32 `protobuf:"fixed32,2,opt,name=ip" json:"ip,omitempty"` + Trusted *bool `protobuf:"varint,3,opt,name=trusted" json:"trusted,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCUpdateSubGCSessionInfo_CMsgUpdate) Reset() { + *m = CMsgGCUpdateSubGCSessionInfo_CMsgUpdate{} +} +func (m *CMsgGCUpdateSubGCSessionInfo_CMsgUpdate) String() string { return proto.CompactTextString(m) } +func (*CMsgGCUpdateSubGCSessionInfo_CMsgUpdate) ProtoMessage() {} +func (*CMsgGCUpdateSubGCSessionInfo_CMsgUpdate) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{16, 0} +} + +func (m *CMsgGCUpdateSubGCSessionInfo_CMsgUpdate) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgGCUpdateSubGCSessionInfo_CMsgUpdate) GetIp() uint32 { + if m != nil && m.Ip != nil { + return *m.Ip + } + return 0 +} + +func (m *CMsgGCUpdateSubGCSessionInfo_CMsgUpdate) GetTrusted() bool { + if m != nil && m.Trusted != nil { + return *m.Trusted + } + return false +} + +type CMsgGCRequestSubGCSessionInfo struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCRequestSubGCSessionInfo) Reset() { *m = CMsgGCRequestSubGCSessionInfo{} } +func (m *CMsgGCRequestSubGCSessionInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgGCRequestSubGCSessionInfo) ProtoMessage() {} +func (*CMsgGCRequestSubGCSessionInfo) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{17} } + +func (m *CMsgGCRequestSubGCSessionInfo) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CMsgGCRequestSubGCSessionInfoResponse struct { + Ip *uint32 `protobuf:"fixed32,1,opt,name=ip" json:"ip,omitempty"` + Trusted *bool `protobuf:"varint,2,opt,name=trusted" json:"trusted,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCRequestSubGCSessionInfoResponse) Reset() { *m = CMsgGCRequestSubGCSessionInfoResponse{} } +func (m *CMsgGCRequestSubGCSessionInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCRequestSubGCSessionInfoResponse) ProtoMessage() {} +func (*CMsgGCRequestSubGCSessionInfoResponse) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{18} +} + +func (m *CMsgGCRequestSubGCSessionInfoResponse) GetIp() uint32 { + if m != nil && m.Ip != nil { + return *m.Ip + } + return 0 +} + +func (m *CMsgGCRequestSubGCSessionInfoResponse) GetTrusted() bool { + if m != nil && m.Trusted != nil { + return *m.Trusted + } + return false +} + +type CMsgSOCacheHaveVersion struct { + Soid *CMsgSOIDOwner `protobuf:"bytes,1,opt,name=soid" json:"soid,omitempty"` + Version *uint64 `protobuf:"fixed64,2,opt,name=version" json:"version,omitempty"` + ServiceId *uint32 `protobuf:"varint,3,opt,name=service_id" json:"service_id,omitempty"` + CachedFileVersion *uint32 `protobuf:"varint,4,opt,name=cached_file_version" json:"cached_file_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgSOCacheHaveVersion) Reset() { *m = CMsgSOCacheHaveVersion{} } +func (m *CMsgSOCacheHaveVersion) String() string { return proto.CompactTextString(m) } +func (*CMsgSOCacheHaveVersion) ProtoMessage() {} +func (*CMsgSOCacheHaveVersion) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{19} } + +func (m *CMsgSOCacheHaveVersion) GetSoid() *CMsgSOIDOwner { + if m != nil { + return m.Soid + } + return nil +} + +func (m *CMsgSOCacheHaveVersion) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgSOCacheHaveVersion) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +func (m *CMsgSOCacheHaveVersion) GetCachedFileVersion() uint32 { + if m != nil && m.CachedFileVersion != nil { + return *m.CachedFileVersion + } + return 0 +} + +type CMsgClientHello struct { + Version *uint32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"` + SocacheHaveVersions []*CMsgSOCacheHaveVersion `protobuf:"bytes,2,rep,name=socache_have_versions" json:"socache_have_versions,omitempty"` + ClientSessionNeed *uint32 `protobuf:"varint,3,opt,name=client_session_need" json:"client_session_need,omitempty"` + ClientLauncher *PartnerAccountType `protobuf:"varint,4,opt,name=client_launcher,enum=PartnerAccountType,def=0" json:"client_launcher,omitempty"` + SecretKey *string `protobuf:"bytes,5,opt,name=secret_key" json:"secret_key,omitempty"` + ClientLanguage *uint32 `protobuf:"varint,6,opt,name=client_language" json:"client_language,omitempty"` + Engine *ESourceEngine `protobuf:"varint,7,opt,name=engine,enum=ESourceEngine,def=0" json:"engine,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientHello) Reset() { *m = CMsgClientHello{} } +func (m *CMsgClientHello) String() string { return proto.CompactTextString(m) } +func (*CMsgClientHello) ProtoMessage() {} +func (*CMsgClientHello) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{20} } + +const Default_CMsgClientHello_ClientLauncher PartnerAccountType = PartnerAccountType_PARTNER_NONE +const Default_CMsgClientHello_Engine ESourceEngine = ESourceEngine_k_ESE_Source1 + +func (m *CMsgClientHello) GetVersion() uint32 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgClientHello) GetSocacheHaveVersions() []*CMsgSOCacheHaveVersion { + if m != nil { + return m.SocacheHaveVersions + } + return nil +} + +func (m *CMsgClientHello) GetClientSessionNeed() uint32 { + if m != nil && m.ClientSessionNeed != nil { + return *m.ClientSessionNeed + } + return 0 +} + +func (m *CMsgClientHello) GetClientLauncher() PartnerAccountType { + if m != nil && m.ClientLauncher != nil { + return *m.ClientLauncher + } + return Default_CMsgClientHello_ClientLauncher +} + +func (m *CMsgClientHello) GetSecretKey() string { + if m != nil && m.SecretKey != nil { + return *m.SecretKey + } + return "" +} + +func (m *CMsgClientHello) GetClientLanguage() uint32 { + if m != nil && m.ClientLanguage != nil { + return *m.ClientLanguage + } + return 0 +} + +func (m *CMsgClientHello) GetEngine() ESourceEngine { + if m != nil && m.Engine != nil { + return *m.Engine + } + return Default_CMsgClientHello_Engine +} + +type CMsgClientWelcome struct { + Version *uint32 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"` + GameData []byte `protobuf:"bytes,2,opt,name=game_data" json:"game_data,omitempty"` + OutofdateSubscribedCaches []*CMsgSOCacheSubscribed `protobuf:"bytes,3,rep,name=outofdate_subscribed_caches" json:"outofdate_subscribed_caches,omitempty"` + UptodateSubscribedCaches []*CMsgSOCacheSubscriptionCheck `protobuf:"bytes,4,rep,name=uptodate_subscribed_caches" json:"uptodate_subscribed_caches,omitempty"` + Location *CMsgClientWelcome_Location `protobuf:"bytes,5,opt,name=location" json:"location,omitempty"` + SaveGameKey []byte `protobuf:"bytes,6,opt,name=save_game_key" json:"save_game_key,omitempty"` + ItemSchemaCrc *uint32 `protobuf:"fixed32,7,opt,name=item_schema_crc" json:"item_schema_crc,omitempty"` + ItemsGameUrl *string `protobuf:"bytes,8,opt,name=items_game_url" json:"items_game_url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWelcome) Reset() { *m = CMsgClientWelcome{} } +func (m *CMsgClientWelcome) String() string { return proto.CompactTextString(m) } +func (*CMsgClientWelcome) ProtoMessage() {} +func (*CMsgClientWelcome) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{21} } + +func (m *CMsgClientWelcome) GetVersion() uint32 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +func (m *CMsgClientWelcome) GetGameData() []byte { + if m != nil { + return m.GameData + } + return nil +} + +func (m *CMsgClientWelcome) GetOutofdateSubscribedCaches() []*CMsgSOCacheSubscribed { + if m != nil { + return m.OutofdateSubscribedCaches + } + return nil +} + +func (m *CMsgClientWelcome) GetUptodateSubscribedCaches() []*CMsgSOCacheSubscriptionCheck { + if m != nil { + return m.UptodateSubscribedCaches + } + return nil +} + +func (m *CMsgClientWelcome) GetLocation() *CMsgClientWelcome_Location { + if m != nil { + return m.Location + } + return nil +} + +func (m *CMsgClientWelcome) GetSaveGameKey() []byte { + if m != nil { + return m.SaveGameKey + } + return nil +} + +func (m *CMsgClientWelcome) GetItemSchemaCrc() uint32 { + if m != nil && m.ItemSchemaCrc != nil { + return *m.ItemSchemaCrc + } + return 0 +} + +func (m *CMsgClientWelcome) GetItemsGameUrl() string { + if m != nil && m.ItemsGameUrl != nil { + return *m.ItemsGameUrl + } + return "" +} + +type CMsgClientWelcome_Location struct { + Latitude *float32 `protobuf:"fixed32,1,opt,name=latitude" json:"latitude,omitempty"` + Longitude *float32 `protobuf:"fixed32,2,opt,name=longitude" json:"longitude,omitempty"` + Country *string `protobuf:"bytes,3,opt,name=country" json:"country,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWelcome_Location) Reset() { *m = CMsgClientWelcome_Location{} } +func (m *CMsgClientWelcome_Location) String() string { return proto.CompactTextString(m) } +func (*CMsgClientWelcome_Location) ProtoMessage() {} +func (*CMsgClientWelcome_Location) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{21, 0} } + +func (m *CMsgClientWelcome_Location) GetLatitude() float32 { + if m != nil && m.Latitude != nil { + return *m.Latitude + } + return 0 +} + +func (m *CMsgClientWelcome_Location) GetLongitude() float32 { + if m != nil && m.Longitude != nil { + return *m.Longitude + } + return 0 +} + +func (m *CMsgClientWelcome_Location) GetCountry() string { + if m != nil && m.Country != nil { + return *m.Country + } + return "" +} + +type CMsgConnectionStatus struct { + Status *GCConnectionStatus `protobuf:"varint,1,opt,name=status,enum=GCConnectionStatus,def=0" json:"status,omitempty"` + ClientSessionNeed *uint32 `protobuf:"varint,2,opt,name=client_session_need" json:"client_session_need,omitempty"` + QueuePosition *int32 `protobuf:"varint,3,opt,name=queue_position" json:"queue_position,omitempty"` + QueueSize *int32 `protobuf:"varint,4,opt,name=queue_size" json:"queue_size,omitempty"` + WaitSeconds *int32 `protobuf:"varint,5,opt,name=wait_seconds" json:"wait_seconds,omitempty"` + EstimatedWaitSecondsRemaining *int32 `protobuf:"varint,6,opt,name=estimated_wait_seconds_remaining" json:"estimated_wait_seconds_remaining,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgConnectionStatus) Reset() { *m = CMsgConnectionStatus{} } +func (m *CMsgConnectionStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgConnectionStatus) ProtoMessage() {} +func (*CMsgConnectionStatus) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{22} } + +const Default_CMsgConnectionStatus_Status GCConnectionStatus = GCConnectionStatus_GCConnectionStatus_HAVE_SESSION + +func (m *CMsgConnectionStatus) GetStatus() GCConnectionStatus { + if m != nil && m.Status != nil { + return *m.Status + } + return Default_CMsgConnectionStatus_Status +} + +func (m *CMsgConnectionStatus) GetClientSessionNeed() uint32 { + if m != nil && m.ClientSessionNeed != nil { + return *m.ClientSessionNeed + } + return 0 +} + +func (m *CMsgConnectionStatus) GetQueuePosition() int32 { + if m != nil && m.QueuePosition != nil { + return *m.QueuePosition + } + return 0 +} + +func (m *CMsgConnectionStatus) GetQueueSize() int32 { + if m != nil && m.QueueSize != nil { + return *m.QueueSize + } + return 0 +} + +func (m *CMsgConnectionStatus) GetWaitSeconds() int32 { + if m != nil && m.WaitSeconds != nil { + return *m.WaitSeconds + } + return 0 +} + +func (m *CMsgConnectionStatus) GetEstimatedWaitSecondsRemaining() int32 { + if m != nil && m.EstimatedWaitSecondsRemaining != nil { + return *m.EstimatedWaitSecondsRemaining + } + return 0 +} + +type CMsgGCToGCSOCacheSubscribe struct { + Subscriber *uint64 `protobuf:"fixed64,1,opt,name=subscriber" json:"subscriber,omitempty"` + SubscribeTo *uint64 `protobuf:"fixed64,2,opt,name=subscribe_to" json:"subscribe_to,omitempty"` + SyncVersion *uint64 `protobuf:"fixed64,3,opt,name=sync_version" json:"sync_version,omitempty"` + HaveVersions []*CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions `protobuf:"bytes,4,rep,name=have_versions" json:"have_versions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCSOCacheSubscribe) Reset() { *m = CMsgGCToGCSOCacheSubscribe{} } +func (m *CMsgGCToGCSOCacheSubscribe) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCSOCacheSubscribe) ProtoMessage() {} +func (*CMsgGCToGCSOCacheSubscribe) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{23} } + +func (m *CMsgGCToGCSOCacheSubscribe) GetSubscriber() uint64 { + if m != nil && m.Subscriber != nil { + return *m.Subscriber + } + return 0 +} + +func (m *CMsgGCToGCSOCacheSubscribe) GetSubscribeTo() uint64 { + if m != nil && m.SubscribeTo != nil { + return *m.SubscribeTo + } + return 0 +} + +func (m *CMsgGCToGCSOCacheSubscribe) GetSyncVersion() uint64 { + if m != nil && m.SyncVersion != nil { + return *m.SyncVersion + } + return 0 +} + +func (m *CMsgGCToGCSOCacheSubscribe) GetHaveVersions() []*CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions { + if m != nil { + return m.HaveVersions + } + return nil +} + +type CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions struct { + ServiceId *uint32 `protobuf:"varint,1,opt,name=service_id" json:"service_id,omitempty"` + Version *uint64 `protobuf:"varint,2,opt,name=version" json:"version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions) Reset() { + *m = CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions{} +} +func (m *CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions) ProtoMessage() {} +func (*CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{23, 0} +} + +func (m *CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions) GetServiceId() uint32 { + if m != nil && m.ServiceId != nil { + return *m.ServiceId + } + return 0 +} + +func (m *CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions) GetVersion() uint64 { + if m != nil && m.Version != nil { + return *m.Version + } + return 0 +} + +type CMsgGCToGCSOCacheUnsubscribe struct { + Subscriber *uint64 `protobuf:"fixed64,1,opt,name=subscriber" json:"subscriber,omitempty"` + UnsubscribeFrom *uint64 `protobuf:"fixed64,2,opt,name=unsubscribe_from" json:"unsubscribe_from,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCSOCacheUnsubscribe) Reset() { *m = CMsgGCToGCSOCacheUnsubscribe{} } +func (m *CMsgGCToGCSOCacheUnsubscribe) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCSOCacheUnsubscribe) ProtoMessage() {} +func (*CMsgGCToGCSOCacheUnsubscribe) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{24} } + +func (m *CMsgGCToGCSOCacheUnsubscribe) GetSubscriber() uint64 { + if m != nil && m.Subscriber != nil { + return *m.Subscriber + } + return 0 +} + +func (m *CMsgGCToGCSOCacheUnsubscribe) GetUnsubscribeFrom() uint64 { + if m != nil && m.UnsubscribeFrom != nil { + return *m.UnsubscribeFrom + } + return 0 +} + +type CMsgGCClientPing struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCClientPing) Reset() { *m = CMsgGCClientPing{} } +func (m *CMsgGCClientPing) String() string { return proto.CompactTextString(m) } +func (*CMsgGCClientPing) ProtoMessage() {} +func (*CMsgGCClientPing) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{25} } + +type CMsgGCToGCLoadSessionSOCache struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCLoadSessionSOCache) Reset() { *m = CMsgGCToGCLoadSessionSOCache{} } +func (m *CMsgGCToGCLoadSessionSOCache) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCLoadSessionSOCache) ProtoMessage() {} +func (*CMsgGCToGCLoadSessionSOCache) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{26} } + +func (m *CMsgGCToGCLoadSessionSOCache) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +type CMsgGCToGCLoadSessionSOCacheResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCLoadSessionSOCacheResponse) Reset() { *m = CMsgGCToGCLoadSessionSOCacheResponse{} } +func (m *CMsgGCToGCLoadSessionSOCacheResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCLoadSessionSOCacheResponse) ProtoMessage() {} +func (*CMsgGCToGCLoadSessionSOCacheResponse) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{27} +} + +type CMsgGCToGCUpdateSessionStats struct { + UserSessions *uint32 `protobuf:"varint,1,opt,name=user_sessions" json:"user_sessions,omitempty"` + ServerSessions *uint32 `protobuf:"varint,2,opt,name=server_sessions" json:"server_sessions,omitempty"` + InLogonSurge *bool `protobuf:"varint,3,opt,name=in_logon_surge" json:"in_logon_surge,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCToGCUpdateSessionStats) Reset() { *m = CMsgGCToGCUpdateSessionStats{} } +func (m *CMsgGCToGCUpdateSessionStats) String() string { return proto.CompactTextString(m) } +func (*CMsgGCToGCUpdateSessionStats) ProtoMessage() {} +func (*CMsgGCToGCUpdateSessionStats) Descriptor() ([]byte, []int) { return gcsdk_fileDescriptor0, []int{28} } + +func (m *CMsgGCToGCUpdateSessionStats) GetUserSessions() uint32 { + if m != nil && m.UserSessions != nil { + return *m.UserSessions + } + return 0 +} + +func (m *CMsgGCToGCUpdateSessionStats) GetServerSessions() uint32 { + if m != nil && m.ServerSessions != nil { + return *m.ServerSessions + } + return 0 +} + +func (m *CMsgGCToGCUpdateSessionStats) GetInLogonSurge() bool { + if m != nil && m.InLogonSurge != nil { + return *m.InLogonSurge + } + return false +} + +type CWorkshop_PopulateItemDescriptions_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Languages []*CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock `protobuf:"bytes,2,rep,name=languages" json:"languages,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_PopulateItemDescriptions_Request) Reset() { + *m = CWorkshop_PopulateItemDescriptions_Request{} +} +func (m *CWorkshop_PopulateItemDescriptions_Request) String() string { + return proto.CompactTextString(m) +} +func (*CWorkshop_PopulateItemDescriptions_Request) ProtoMessage() {} +func (*CWorkshop_PopulateItemDescriptions_Request) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{29} +} + +func (m *CWorkshop_PopulateItemDescriptions_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CWorkshop_PopulateItemDescriptions_Request) GetLanguages() []*CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock { + if m != nil { + return m.Languages + } + return nil +} + +type CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription struct { + Gameitemid *uint32 `protobuf:"varint,1,opt,name=gameitemid" json:"gameitemid,omitempty"` + ItemDescription *string `protobuf:"bytes,2,opt,name=item_description" json:"item_description,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription) Reset() { + *m = CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription{} +} +func (m *CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription) String() string { + return proto.CompactTextString(m) +} +func (*CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription) ProtoMessage() {} +func (*CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{29, 0} +} + +func (m *CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription) GetGameitemid() uint32 { + if m != nil && m.Gameitemid != nil { + return *m.Gameitemid + } + return 0 +} + +func (m *CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription) GetItemDescription() string { + if m != nil && m.ItemDescription != nil { + return *m.ItemDescription + } + return "" +} + +type CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock struct { + Language *string `protobuf:"bytes,1,opt,name=language" json:"language,omitempty"` + Descriptions []*CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription `protobuf:"bytes,2,rep,name=descriptions" json:"descriptions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock) Reset() { + *m = CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock{} +} +func (m *CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock) String() string { + return proto.CompactTextString(m) +} +func (*CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock) ProtoMessage() {} +func (*CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{29, 1} +} + +func (m *CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock) GetLanguage() string { + if m != nil && m.Language != nil { + return *m.Language + } + return "" +} + +func (m *CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock) GetDescriptions() []*CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription { + if m != nil { + return m.Descriptions + } + return nil +} + +type CWorkshop_GetContributors_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Gameitemid *uint32 `protobuf:"varint,2,opt,name=gameitemid" json:"gameitemid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_GetContributors_Request) Reset() { *m = CWorkshop_GetContributors_Request{} } +func (m *CWorkshop_GetContributors_Request) String() string { return proto.CompactTextString(m) } +func (*CWorkshop_GetContributors_Request) ProtoMessage() {} +func (*CWorkshop_GetContributors_Request) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{30} +} + +func (m *CWorkshop_GetContributors_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CWorkshop_GetContributors_Request) GetGameitemid() uint32 { + if m != nil && m.Gameitemid != nil { + return *m.Gameitemid + } + return 0 +} + +type CWorkshop_GetContributors_Response struct { + Contributors []uint64 `protobuf:"fixed64,1,rep,name=contributors" json:"contributors,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_GetContributors_Response) Reset() { *m = CWorkshop_GetContributors_Response{} } +func (m *CWorkshop_GetContributors_Response) String() string { return proto.CompactTextString(m) } +func (*CWorkshop_GetContributors_Response) ProtoMessage() {} +func (*CWorkshop_GetContributors_Response) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{31} +} + +func (m *CWorkshop_GetContributors_Response) GetContributors() []uint64 { + if m != nil { + return m.Contributors + } + return nil +} + +type CWorkshop_SetItemPaymentRules_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Gameitemid *uint32 `protobuf:"varint,2,opt,name=gameitemid" json:"gameitemid,omitempty"` + AssociatedWorkshopFiles []*CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule `protobuf:"bytes,3,rep,name=associated_workshop_files" json:"associated_workshop_files,omitempty"` + PartnerAccounts []*CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule `protobuf:"bytes,4,rep,name=partner_accounts" json:"partner_accounts,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_SetItemPaymentRules_Request) Reset() { *m = CWorkshop_SetItemPaymentRules_Request{} } +func (m *CWorkshop_SetItemPaymentRules_Request) String() string { return proto.CompactTextString(m) } +func (*CWorkshop_SetItemPaymentRules_Request) ProtoMessage() {} +func (*CWorkshop_SetItemPaymentRules_Request) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{32} +} + +func (m *CWorkshop_SetItemPaymentRules_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CWorkshop_SetItemPaymentRules_Request) GetGameitemid() uint32 { + if m != nil && m.Gameitemid != nil { + return *m.Gameitemid + } + return 0 +} + +func (m *CWorkshop_SetItemPaymentRules_Request) GetAssociatedWorkshopFiles() []*CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule { + if m != nil { + return m.AssociatedWorkshopFiles + } + return nil +} + +func (m *CWorkshop_SetItemPaymentRules_Request) GetPartnerAccounts() []*CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule { + if m != nil { + return m.PartnerAccounts + } + return nil +} + +type CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule struct { + WorkshopFileId *uint64 `protobuf:"varint,1,opt,name=workshop_file_id" json:"workshop_file_id,omitempty"` + RevenuePercentage *float32 `protobuf:"fixed32,2,opt,name=revenue_percentage" json:"revenue_percentage,omitempty"` + RuleDescription *string `protobuf:"bytes,3,opt,name=rule_description" json:"rule_description,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule) Reset() { + *m = CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule{} +} +func (m *CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule) String() string { + return proto.CompactTextString(m) +} +func (*CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule) ProtoMessage() {} +func (*CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{32, 0} +} + +func (m *CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule) GetWorkshopFileId() uint64 { + if m != nil && m.WorkshopFileId != nil { + return *m.WorkshopFileId + } + return 0 +} + +func (m *CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule) GetRevenuePercentage() float32 { + if m != nil && m.RevenuePercentage != nil { + return *m.RevenuePercentage + } + return 0 +} + +func (m *CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule) GetRuleDescription() string { + if m != nil && m.RuleDescription != nil { + return *m.RuleDescription + } + return "" +} + +type CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule struct { + AccountId *uint32 `protobuf:"varint,1,opt,name=account_id" json:"account_id,omitempty"` + RevenuePercentage *float32 `protobuf:"fixed32,2,opt,name=revenue_percentage" json:"revenue_percentage,omitempty"` + RuleDescription *string `protobuf:"bytes,3,opt,name=rule_description" json:"rule_description,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule) Reset() { + *m = CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule{} +} +func (m *CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule) String() string { + return proto.CompactTextString(m) +} +func (*CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule) ProtoMessage() {} +func (*CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{32, 1} +} + +func (m *CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule) GetAccountId() uint32 { + if m != nil && m.AccountId != nil { + return *m.AccountId + } + return 0 +} + +func (m *CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule) GetRevenuePercentage() float32 { + if m != nil && m.RevenuePercentage != nil { + return *m.RevenuePercentage + } + return 0 +} + +func (m *CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule) GetRuleDescription() string { + if m != nil && m.RuleDescription != nil { + return *m.RuleDescription + } + return "" +} + +type CWorkshop_SetItemPaymentRules_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CWorkshop_SetItemPaymentRules_Response) Reset() { + *m = CWorkshop_SetItemPaymentRules_Response{} +} +func (m *CWorkshop_SetItemPaymentRules_Response) String() string { return proto.CompactTextString(m) } +func (*CWorkshop_SetItemPaymentRules_Response) ProtoMessage() {} +func (*CWorkshop_SetItemPaymentRules_Response) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{33} +} + +type CBroadcast_PostGameDataFrame_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Steamid *uint64 `protobuf:"fixed64,2,opt,name=steamid" json:"steamid,omitempty"` + BroadcastId *uint64 `protobuf:"fixed64,3,opt,name=broadcast_id" json:"broadcast_id,omitempty"` + FrameData []byte `protobuf:"bytes,4,opt,name=frame_data" json:"frame_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CBroadcast_PostGameDataFrame_Request) Reset() { *m = CBroadcast_PostGameDataFrame_Request{} } +func (m *CBroadcast_PostGameDataFrame_Request) String() string { return proto.CompactTextString(m) } +func (*CBroadcast_PostGameDataFrame_Request) ProtoMessage() {} +func (*CBroadcast_PostGameDataFrame_Request) Descriptor() ([]byte, []int) { + return gcsdk_fileDescriptor0, []int{34} +} + +func (m *CBroadcast_PostGameDataFrame_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CBroadcast_PostGameDataFrame_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CBroadcast_PostGameDataFrame_Request) GetBroadcastId() uint64 { + if m != nil && m.BroadcastId != nil { + return *m.BroadcastId + } + return 0 +} + +func (m *CBroadcast_PostGameDataFrame_Request) GetFrameData() []byte { + if m != nil { + return m.FrameData + } + return nil +} + +func init() { + proto.RegisterType((*CMsgSHA1Digest)(nil), "CMsgSHA1Digest") + proto.RegisterType((*CMsgSOIDOwner)(nil), "CMsgSOIDOwner") + proto.RegisterType((*CMsgSOSingleObject)(nil), "CMsgSOSingleObject") + proto.RegisterType((*CMsgSOMultipleObjects)(nil), "CMsgSOMultipleObjects") + proto.RegisterType((*CMsgSOMultipleObjects_SingleObject)(nil), "CMsgSOMultipleObjects.SingleObject") + proto.RegisterType((*CMsgSOCacheSubscribed)(nil), "CMsgSOCacheSubscribed") + proto.RegisterType((*CMsgSOCacheSubscribed_SubscribedType)(nil), "CMsgSOCacheSubscribed.SubscribedType") + proto.RegisterType((*CMsgSOCacheSubscribedUpToDate)(nil), "CMsgSOCacheSubscribedUpToDate") + proto.RegisterType((*CMsgSOCacheUnsubscribed)(nil), "CMsgSOCacheUnsubscribed") + proto.RegisterType((*CMsgSOCacheSubscriptionCheck)(nil), "CMsgSOCacheSubscriptionCheck") + proto.RegisterType((*CMsgSOCacheSubscriptionRefresh)(nil), "CMsgSOCacheSubscriptionRefresh") + proto.RegisterType((*CMsgSOCacheVersion)(nil), "CMsgSOCacheVersion") + proto.RegisterType((*CMsgGCMultiplexMessage)(nil), "CMsgGCMultiplexMessage") + proto.RegisterType((*CGCToGCMsgMasterAck)(nil), "CGCToGCMsgMasterAck") + proto.RegisterType((*CGCToGCMsgMasterAck_Process)(nil), "CGCToGCMsgMasterAck.Process") + proto.RegisterType((*CGCToGCMsgMasterAck_Response)(nil), "CGCToGCMsgMasterAck_Response") + proto.RegisterType((*CGCToGCMsgMasterStartupComplete)(nil), "CGCToGCMsgMasterStartupComplete") + proto.RegisterType((*CGCToGCMsgMasterStartupComplete_GCInfo)(nil), "CGCToGCMsgMasterStartupComplete.GCInfo") + proto.RegisterType((*CGCToGCMsgRouted)(nil), "CGCToGCMsgRouted") + proto.RegisterType((*CGCToGCMsgRoutedReply)(nil), "CGCToGCMsgRoutedReply") + proto.RegisterType((*CMsgGCUpdateSubGCSessionInfo)(nil), "CMsgGCUpdateSubGCSessionInfo") + proto.RegisterType((*CMsgGCUpdateSubGCSessionInfo_CMsgUpdate)(nil), "CMsgGCUpdateSubGCSessionInfo.CMsgUpdate") + proto.RegisterType((*CMsgGCRequestSubGCSessionInfo)(nil), "CMsgGCRequestSubGCSessionInfo") + proto.RegisterType((*CMsgGCRequestSubGCSessionInfoResponse)(nil), "CMsgGCRequestSubGCSessionInfoResponse") + proto.RegisterType((*CMsgSOCacheHaveVersion)(nil), "CMsgSOCacheHaveVersion") + proto.RegisterType((*CMsgClientHello)(nil), "CMsgClientHello") + proto.RegisterType((*CMsgClientWelcome)(nil), "CMsgClientWelcome") + proto.RegisterType((*CMsgClientWelcome_Location)(nil), "CMsgClientWelcome.Location") + proto.RegisterType((*CMsgConnectionStatus)(nil), "CMsgConnectionStatus") + proto.RegisterType((*CMsgGCToGCSOCacheSubscribe)(nil), "CMsgGCToGCSOCacheSubscribe") + proto.RegisterType((*CMsgGCToGCSOCacheSubscribe_CMsgHaveVersions)(nil), "CMsgGCToGCSOCacheSubscribe.CMsgHaveVersions") + proto.RegisterType((*CMsgGCToGCSOCacheUnsubscribe)(nil), "CMsgGCToGCSOCacheUnsubscribe") + proto.RegisterType((*CMsgGCClientPing)(nil), "CMsgGCClientPing") + proto.RegisterType((*CMsgGCToGCLoadSessionSOCache)(nil), "CMsgGCToGCLoadSessionSOCache") + proto.RegisterType((*CMsgGCToGCLoadSessionSOCacheResponse)(nil), "CMsgGCToGCLoadSessionSOCacheResponse") + proto.RegisterType((*CMsgGCToGCUpdateSessionStats)(nil), "CMsgGCToGCUpdateSessionStats") + proto.RegisterType((*CWorkshop_PopulateItemDescriptions_Request)(nil), "CWorkshop_PopulateItemDescriptions_Request") + proto.RegisterType((*CWorkshop_PopulateItemDescriptions_Request_SingleItemDescription)(nil), "CWorkshop_PopulateItemDescriptions_Request.SingleItemDescription") + proto.RegisterType((*CWorkshop_PopulateItemDescriptions_Request_ItemDescriptionsLanguageBlock)(nil), "CWorkshop_PopulateItemDescriptions_Request.ItemDescriptionsLanguageBlock") + proto.RegisterType((*CWorkshop_GetContributors_Request)(nil), "CWorkshop_GetContributors_Request") + proto.RegisterType((*CWorkshop_GetContributors_Response)(nil), "CWorkshop_GetContributors_Response") + proto.RegisterType((*CWorkshop_SetItemPaymentRules_Request)(nil), "CWorkshop_SetItemPaymentRules_Request") + proto.RegisterType((*CWorkshop_SetItemPaymentRules_Request_WorkshopItemPaymentRule)(nil), "CWorkshop_SetItemPaymentRules_Request.WorkshopItemPaymentRule") + proto.RegisterType((*CWorkshop_SetItemPaymentRules_Request_PartnerItemPaymentRule)(nil), "CWorkshop_SetItemPaymentRules_Request.PartnerItemPaymentRule") + proto.RegisterType((*CWorkshop_SetItemPaymentRules_Response)(nil), "CWorkshop_SetItemPaymentRules_Response") + proto.RegisterType((*CBroadcast_PostGameDataFrame_Request)(nil), "CBroadcast_PostGameDataFrame_Request") + proto.RegisterEnum("ESourceEngine", ESourceEngine_name, ESourceEngine_value) + proto.RegisterEnum("PartnerAccountType", PartnerAccountType_name, PartnerAccountType_value) + proto.RegisterEnum("GCConnectionStatus", GCConnectionStatus_name, GCConnectionStatus_value) +} + +var gcsdk_fileDescriptor0 = []byte{ + // 1996 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x57, 0x4b, 0x73, 0xe3, 0x58, + 0x15, 0x1e, 0xc9, 0xaf, 0xf4, 0x89, 0x9d, 0x78, 0x94, 0x49, 0x3a, 0xe3, 0x4e, 0xd3, 0x3d, 0xea, + 0xe9, 0x99, 0xd0, 0x35, 0x23, 0xa6, 0x0d, 0x0c, 0x60, 0xe8, 0xa9, 0x49, 0xdb, 0x6e, 0x27, 0x55, + 0x89, 0x1d, 0xec, 0xa4, 0xc3, 0x82, 0xaa, 0x5b, 0x8a, 0x7c, 0xe3, 0x88, 0xd8, 0x92, 0xd0, 0x95, + 0x32, 0x1d, 0x56, 0x5d, 0xc5, 0x86, 0x62, 0x01, 0x0b, 0x60, 0xcf, 0x8a, 0x3f, 0xc1, 0xef, 0x60, + 0x03, 0x6b, 0x96, 0x54, 0xf1, 0x03, 0x58, 0x70, 0xee, 0xbd, 0x92, 0x1f, 0xb2, 0x9c, 0xb8, 0x67, + 0x93, 0x52, 0xce, 0x3d, 0xef, 0xc7, 0x77, 0x8e, 0x61, 0x6b, 0x60, 0xb1, 0xfe, 0x15, 0x19, 0x58, + 0x23, 0xca, 0x98, 0x39, 0xa0, 0xcc, 0xf0, 0x7c, 0x37, 0x70, 0x2b, 0x1b, 0x2c, 0xa0, 0xe6, 0x68, + 0x96, 0xa8, 0x7f, 0x0d, 0x6b, 0xf5, 0x23, 0x36, 0xe8, 0xed, 0xef, 0x3d, 0x6f, 0xd8, 0x48, 0x0e, + 0xb4, 0x35, 0xc8, 0x9f, 0x0f, 0x5d, 0xeb, 0xea, 0xf9, 0xb6, 0xf2, 0x58, 0xdd, 0xcd, 0x8f, 0xff, + 0xaf, 0x6e, 0xab, 0x33, 0xff, 0x7f, 0x7f, 0x3b, 0x83, 0xff, 0x17, 0xf4, 0xef, 0x42, 0x49, 0x68, + 0xe8, 0x1c, 0x34, 0x3a, 0xdf, 0x38, 0xd4, 0xd7, 0x8a, 0x90, 0x0d, 0x6e, 0x3c, 0x8a, 0xe2, 0xca, + 0x6e, 0x49, 0x03, 0x50, 0xed, 0x3e, 0x8a, 0x2a, 0xbb, 0x59, 0xfd, 0xb7, 0x0a, 0x68, 0x92, 0xb7, + 0x67, 0x3b, 0x83, 0x21, 0xed, 0x9c, 0xff, 0x8a, 0x5a, 0x81, 0xb6, 0x0e, 0x05, 0x2e, 0x40, 0x22, + 0xbe, 0x9c, 0xb6, 0x01, 0xab, 0xae, 0x78, 0x22, 0x7d, 0x33, 0x30, 0xd1, 0x8e, 0xb2, 0x5b, 0xe4, + 0x5c, 0xd7, 0xd4, 0x67, 0xb6, 0xeb, 0x6c, 0x67, 0x91, 0x90, 0xd7, 0x74, 0x00, 0x97, 0x1b, 0x24, + 0xcc, 0x45, 0xc9, 0x1c, 0xd2, 0x56, 0xab, 0x6b, 0xc6, 0xac, 0x2f, 0x68, 0x9e, 0x51, 0xff, 0xda, + 0xb6, 0x84, 0xf6, 0x3c, 0xf7, 0x48, 0xff, 0x97, 0x0a, 0x9b, 0x92, 0xeb, 0x28, 0x1c, 0x06, 0xb6, + 0x17, 0xfb, 0xc1, 0xb4, 0x17, 0x50, 0x96, 0x76, 0x19, 0x19, 0xb9, 0x7d, 0xfb, 0xc2, 0xa6, 0xdc, + 0xa3, 0x0c, 0xea, 0x7d, 0x62, 0xa4, 0x4a, 0x18, 0xc9, 0x38, 0x62, 0x0f, 0x33, 0xc2, 0xc3, 0x1a, + 0x94, 0x62, 0x7d, 0x66, 0xbf, 0x8f, 0xca, 0xb2, 0xcb, 0x2b, 0xfb, 0x19, 0xac, 0xc7, 0xb2, 0x3e, + 0x1d, 0xb9, 0xd7, 0x94, 0x87, 0xb8, 0xb4, 0xf4, 0x6c, 0x6e, 0xf2, 0x4b, 0xe4, 0xa6, 0xc0, 0x73, + 0x53, 0xf9, 0x1a, 0x8a, 0x8b, 0x4a, 0xa3, 0xa4, 0x95, 0x86, 0xd7, 0xab, 0x58, 0x83, 0xb7, 0x7f, + 0x7b, 0xf8, 0x56, 0xfd, 0x1d, 0xfe, 0x59, 0xd1, 0xff, 0xa7, 0xc4, 0xd9, 0xad, 0x9b, 0xd6, 0x25, + 0xed, 0x85, 0xe7, 0xcc, 0xf2, 0xed, 0x73, 0xda, 0xd7, 0xbe, 0x84, 0x42, 0x14, 0x51, 0x94, 0xd4, + 0xa7, 0x46, 0x2a, 0xa3, 0x31, 0xf9, 0x3c, 0x41, 0xdb, 0xf3, 0x69, 0x9d, 0x0d, 0x2e, 0xbb, 0x44, + 0x70, 0x39, 0xd1, 0x8a, 0x1f, 0x40, 0x31, 0xa6, 0x0d, 0x6d, 0x16, 0x60, 0x5a, 0x32, 0x11, 0xf5, + 0xc6, 0xb1, 0x48, 0x6c, 0x83, 0x27, 0x22, 0x5f, 0xf9, 0x12, 0xd6, 0xe6, 0xdd, 0xb8, 0x23, 0x15, + 0x99, 0xdd, 0xa2, 0xfe, 0x67, 0x05, 0x1e, 0xa6, 0x46, 0x75, 0xea, 0x9d, 0xb8, 0x0d, 0x33, 0x98, + 0x09, 0x47, 0x49, 0x09, 0x47, 0x5d, 0x22, 0x9c, 0x4c, 0x6a, 0x38, 0xd9, 0xd4, 0x70, 0x78, 0xe8, + 0x79, 0xfd, 0x05, 0xdc, 0x9f, 0xf2, 0xea, 0xd4, 0x61, 0x93, 0xb2, 0x2c, 0x61, 0x5e, 0xff, 0x93, + 0x02, 0x3b, 0xf3, 0x51, 0x79, 0x01, 0x1a, 0xa8, 0x5f, 0x52, 0xeb, 0x6a, 0x3a, 0x28, 0x35, 0x25, + 0xa8, 0xcc, 0x12, 0x41, 0x65, 0x53, 0x83, 0xca, 0xa5, 0x06, 0x95, 0x17, 0x41, 0x35, 0xe0, 0x3b, + 0x0b, 0x9c, 0xea, 0xd2, 0x0b, 0x9f, 0xb2, 0xcb, 0xa5, 0x62, 0x7b, 0x1a, 0x63, 0x92, 0xd0, 0xf2, + 0x5a, 0x5a, 0x98, 0xab, 0x92, 0x7e, 0x08, 0x5b, 0x9c, 0xad, 0x55, 0x8f, 0xe7, 0xee, 0xcd, 0x91, + 0x44, 0x52, 0xce, 0x3a, 0x62, 0x83, 0x29, 0xc8, 0x43, 0x82, 0x67, 0xde, 0x0c, 0x5d, 0x53, 0x9a, + 0x2c, 0x6a, 0x65, 0x58, 0x11, 0xd8, 0x6b, 0xf7, 0x19, 0xa6, 0x22, 0x83, 0xda, 0xfe, 0xae, 0xc0, + 0x46, 0xbd, 0x55, 0x3f, 0x71, 0x5b, 0x5c, 0xe9, 0x91, 0x89, 0xcf, 0xfe, 0x1e, 0xe6, 0xf1, 0x7d, + 0xb8, 0xd7, 0xb7, 0x7d, 0x62, 0x3b, 0x7d, 0xfa, 0x26, 0xd2, 0x86, 0xb1, 0x8f, 0xd0, 0x33, 0xdb, + 0xa1, 0xc4, 0x31, 0x47, 0x54, 0xe4, 0xf2, 0x1e, 0xa7, 0x22, 0x80, 0x5b, 0xe8, 0x82, 0xa4, 0x66, + 0x05, 0xf5, 0x7b, 0x42, 0x1c, 0x5b, 0xd2, 0xf5, 0x6f, 0x44, 0x7b, 0xaf, 0x56, 0x77, 0x8c, 0x14, + 0x3b, 0xc6, 0xb1, 0x94, 0xad, 0xfc, 0x00, 0x0a, 0xd1, 0x67, 0x9a, 0xe9, 0x2d, 0x58, 0x93, 0x2d, + 0xef, 0xb0, 0xc0, 0x74, 0x90, 0x4b, 0x34, 0x79, 0x49, 0xaf, 0x62, 0x37, 0xcc, 0x2b, 0x25, 0x5d, + 0xca, 0x3c, 0xd7, 0x61, 0x14, 0x0b, 0x5b, 0xa0, 0x98, 0x7f, 0x4c, 0x94, 0x1c, 0x95, 0x9a, 0x52, + 0xd5, 0xff, 0xa0, 0xc0, 0xa3, 0xa4, 0x50, 0x2f, 0x30, 0xfd, 0x20, 0xf4, 0xea, 0xee, 0x08, 0xf3, + 0x89, 0xa3, 0xf1, 0x63, 0x28, 0x0c, 0x2c, 0xb4, 0x76, 0xe1, 0xa2, 0x1c, 0x77, 0xfe, 0x53, 0xe3, + 0x0e, 0x11, 0xa3, 0x55, 0x3f, 0x40, 0xf6, 0xca, 0x73, 0xc8, 0xcb, 0xaf, 0x65, 0x32, 0xc8, 0x8b, + 0x72, 0x0f, 0x0b, 0x5a, 0x9e, 0x28, 0xef, 0xba, 0x61, 0x80, 0xb3, 0x80, 0x85, 0xc2, 0x52, 0x92, + 0xa9, 0x5a, 0xa2, 0x3a, 0x46, 0x51, 0x97, 0x1f, 0x6f, 0xa7, 0x3c, 0x9f, 0x7b, 0x87, 0x06, 0x24, + 0x5a, 0xa4, 0x72, 0x3b, 0xe9, 0x5f, 0x21, 0xea, 0x25, 0xb4, 0x75, 0xa9, 0x37, 0xbc, 0x49, 0x51, + 0x99, 0x90, 0x17, 0x2d, 0xa2, 0xff, 0x25, 0x9a, 0xb0, 0x56, 0xfd, 0xd4, 0x43, 0x38, 0xe1, 0xdd, + 0xdc, 0xaa, 0xf7, 0x90, 0x05, 0x3b, 0x50, 0xc4, 0xf5, 0x13, 0x28, 0x84, 0xe2, 0x85, 0x45, 0xb9, + 0xd9, 0x35, 0x6e, 0xe3, 0x17, 0x8f, 0xf2, 0xa9, 0x52, 0x03, 0x98, 0xfc, 0xc7, 0xbb, 0x33, 0x6a, + 0xc6, 0x08, 0x7f, 0xf8, 0x86, 0xf6, 0x84, 0x1b, 0x05, 0x01, 0x72, 0x7e, 0x88, 0xef, 0x72, 0x66, + 0x57, 0xf4, 0x2f, 0x24, 0x9c, 0xb5, 0xea, 0x5d, 0xfa, 0xeb, 0x10, 0xcf, 0x83, 0x39, 0xbf, 0x92, + 0xea, 0x70, 0x2a, 0x9f, 0xde, 0x2a, 0x31, 0xee, 0x12, 0x69, 0x57, 0x49, 0xda, 0x55, 0x85, 0xdd, + 0x37, 0x72, 0xdc, 0xa2, 0xa9, 0xdc, 0x37, 0xaf, 0xc7, 0x93, 0xb9, 0x03, 0x59, 0x31, 0xcd, 0x4a, + 0x2a, 0xa6, 0xcc, 0x01, 0x51, 0x1a, 0x72, 0x3e, 0x80, 0x0d, 0x8b, 0xab, 0xed, 0x93, 0x0b, 0x7b, + 0x48, 0xc9, 0xf4, 0x59, 0x51, 0xd2, 0xff, 0xa8, 0xc2, 0x3a, 0xd7, 0x59, 0x1f, 0xda, 0xd4, 0x09, + 0xf6, 0xe9, 0x70, 0xe8, 0x26, 0xd1, 0xa0, 0x84, 0xbb, 0x6c, 0x93, 0xb9, 0x42, 0x07, 0xb9, 0x44, + 0xdf, 0x62, 0x15, 0xf1, 0x66, 0xbb, 0x6f, 0x2c, 0x70, 0x9e, 0x5b, 0x16, 0x7a, 0x09, 0x93, 0x19, + 0x21, 0x0e, 0xa5, 0xb1, 0x5b, 0x35, 0x58, 0x8f, 0x1e, 0x87, 0x66, 0xe8, 0xa0, 0xa4, 0x2f, 0x5c, + 0x5a, 0xab, 0x6e, 0x18, 0xc7, 0xd8, 0xf5, 0x0e, 0x9f, 0x32, 0xcb, 0x0d, 0x9d, 0x80, 0xef, 0xa3, + 0x5a, 0xf1, 0x78, 0xaf, 0x7b, 0xd2, 0x6e, 0x76, 0x49, 0xbb, 0xd3, 0x6e, 0xca, 0x30, 0x2d, 0x1f, + 0xfb, 0xea, 0x8a, 0xde, 0x08, 0xd0, 0xbf, 0xa7, 0xdd, 0x9f, 0xd2, 0xe7, 0x0c, 0x42, 0xde, 0x6c, + 0xe2, 0x02, 0xd2, 0x3e, 0x87, 0x3c, 0x75, 0x06, 0x38, 0x0f, 0x62, 0xd9, 0xad, 0x61, 0x12, 0x9b, + 0x3d, 0x37, 0xf4, 0x2d, 0xda, 0x14, 0xd4, 0x5a, 0xe9, 0x8a, 0x34, 0x7b, 0x4d, 0x22, 0x69, 0xcf, + 0xf5, 0xff, 0xaa, 0xf0, 0xfe, 0x24, 0x23, 0x67, 0x74, 0x68, 0xb9, 0x23, 0x3a, 0x9f, 0x13, 0x1c, + 0x95, 0x01, 0x8e, 0xd7, 0xd4, 0x61, 0xa0, 0xfd, 0x14, 0x1e, 0xe0, 0x28, 0xb8, 0x17, 0xbc, 0xf1, + 0xc8, 0x64, 0xe7, 0x10, 0x91, 0x39, 0x89, 0x85, 0xab, 0xd5, 0xad, 0xf4, 0x33, 0x40, 0xdb, 0x83, + 0x4a, 0xe8, 0x05, 0xee, 0x02, 0x59, 0x79, 0x4a, 0x3d, 0x34, 0x6e, 0x5d, 0x4b, 0x9f, 0xc3, 0x0a, + 0x9e, 0xaa, 0x66, 0x10, 0x2f, 0xc2, 0xd5, 0xea, 0x03, 0x63, 0x2e, 0x12, 0xe3, 0x30, 0x62, 0xd1, + 0x36, 0xa1, 0xc4, 0x78, 0x35, 0x45, 0x18, 0x3c, 0x8f, 0x79, 0x11, 0x05, 0xe6, 0xd1, 0x0e, 0xe8, + 0x88, 0x30, 0xb4, 0x31, 0x32, 0x89, 0xe5, 0x5b, 0x22, 0x6f, 0x05, 0x8e, 0x8f, 0xfc, 0x81, 0x49, + 0x81, 0xd0, 0x1f, 0x6e, 0xaf, 0xf0, 0xc4, 0xe3, 0x15, 0xb5, 0x32, 0xd6, 0x89, 0xf3, 0x3f, 0xc4, + 0xaf, 0x20, 0xec, 0xcb, 0xf9, 0x57, 0x79, 0x9e, 0x86, 0x2e, 0x26, 0x5a, 0x90, 0x54, 0x41, 0xc2, + 0x5c, 0x8a, 0xc2, 0x22, 0x6a, 0x0b, 0x78, 0xd7, 0xff, 0xad, 0xc0, 0x07, 0xc2, 0x51, 0xd7, 0x71, + 0x10, 0xce, 0x51, 0x11, 0x02, 0x5f, 0x10, 0x32, 0xad, 0x01, 0x79, 0x26, 0xbe, 0x84, 0x32, 0xde, + 0x1a, 0xad, 0x7a, 0x92, 0xa9, 0xf6, 0x68, 0x9e, 0x46, 0xf6, 0xf7, 0x5e, 0x63, 0x45, 0x9b, 0xbd, + 0xde, 0x41, 0xa7, 0xbd, 0xa8, 0x0d, 0xd5, 0x18, 0xf5, 0x71, 0x70, 0x43, 0x4a, 0x3c, 0x97, 0xd9, + 0x41, 0x7c, 0x76, 0xe5, 0x78, 0x8b, 0x49, 0x3a, 0xb3, 0x7f, 0x23, 0x17, 0x4e, 0x8e, 0x43, 0xeb, + 0x37, 0xa6, 0xcd, 0xd5, 0x58, 0xae, 0x83, 0xdb, 0x2d, 0x27, 0xa8, 0xbb, 0xf0, 0x18, 0x07, 0xdf, + 0x1e, 0x61, 0xe5, 0xfa, 0x64, 0xfa, 0x9d, 0x9f, 0xb2, 0xa6, 0xed, 0xe0, 0x85, 0x29, 0x52, 0x9b, + 0xd3, 0xff, 0xa9, 0x40, 0x45, 0xa2, 0x05, 0x87, 0xce, 0x64, 0x0f, 0x88, 0xae, 0x8e, 0xff, 0xf1, + 0x23, 0xb8, 0xe2, 0xb7, 0x40, 0x4c, 0x23, 0x81, 0x1b, 0x8d, 0x79, 0xf2, 0x42, 0x90, 0x97, 0x62, + 0x1d, 0x4a, 0xb3, 0xe3, 0x29, 0xbb, 0xe6, 0x33, 0x63, 0xb1, 0x4d, 0xf1, 0x34, 0x35, 0xb2, 0xac, + 0xf2, 0x23, 0x5c, 0x14, 0x09, 0x5a, 0x02, 0x55, 0xc6, 0x6b, 0x7f, 0x1a, 0x7a, 0xb2, 0xb8, 0x61, + 0x76, 0xe6, 0xec, 0x4c, 0x9d, 0x5e, 0xa9, 0xd1, 0x6d, 0x43, 0x39, 0x9c, 0xb0, 0x90, 0x0b, 0xdf, + 0x1d, 0xc9, 0x08, 0x75, 0x4d, 0xba, 0x81, 0xa5, 0x15, 0x95, 0x3b, 0xc6, 0x24, 0x8a, 0x45, 0x3c, + 0xb6, 0x70, 0x88, 0x07, 0x47, 0x84, 0xb3, 0x91, 0x31, 0x6e, 0xc1, 0x94, 0x90, 0x31, 0x76, 0x53, + 0xff, 0x04, 0x3e, 0xbe, 0x4d, 0x26, 0x86, 0x67, 0xfd, 0x62, 0x5a, 0x77, 0xb4, 0x64, 0x22, 0x4e, + 0xec, 0x28, 0xc6, 0x87, 0x25, 0x64, 0xfc, 0xb4, 0x92, 0x44, 0x16, 0x65, 0x01, 0x87, 0x85, 0x67, + 0x66, 0xfa, 0x61, 0xdc, 0x56, 0xb6, 0x43, 0x86, 0xee, 0x00, 0xbb, 0x8d, 0x85, 0x7e, 0xb4, 0x39, + 0x57, 0xf4, 0xff, 0xa8, 0xf0, 0xac, 0x7e, 0xe6, 0xfa, 0x57, 0xec, 0xd2, 0xf5, 0xc8, 0xb1, 0xeb, + 0x85, 0x38, 0x2f, 0xf4, 0x00, 0xe7, 0xaa, 0x41, 0xc7, 0xe3, 0xcc, 0x48, 0xb4, 0x4d, 0xb4, 0x12, + 0xe4, 0x4c, 0xcf, 0x1b, 0x27, 0xfd, 0x97, 0x38, 0x4c, 0x11, 0xb8, 0xc5, 0xe0, 0x7b, 0x60, 0x2c, + 0xaf, 0xce, 0x48, 0x3e, 0x1c, 0x46, 0xca, 0x5e, 0xf2, 0x9f, 0xb8, 0x95, 0x26, 0x6c, 0xca, 0x9f, + 0x43, 0x09, 0x36, 0x9e, 0x58, 0x3e, 0xf3, 0x7c, 0xfa, 0xc7, 0xae, 0x60, 0xe9, 0x04, 0x4c, 0xf4, + 0x27, 0x7c, 0xf2, 0xd4, 0xa8, 0xfc, 0x1e, 0x7f, 0x14, 0xdc, 0x6a, 0x48, 0xa2, 0x44, 0x84, 0xd1, + 0x8a, 0x00, 0xef, 0x33, 0x28, 0x4e, 0x29, 0x8a, 0x63, 0xdb, 0x7b, 0x97, 0xd8, 0x52, 0x5d, 0xd7, + 0x5f, 0xc1, 0x47, 0x13, 0x1d, 0x2d, 0x1a, 0x20, 0x52, 0x04, 0xd8, 0x6b, 0x08, 0xd3, 0xfe, 0xc2, + 0x2c, 0xcf, 0x86, 0x2b, 0xea, 0xa9, 0xd7, 0x40, 0xbf, 0x4d, 0x4f, 0xb4, 0xe4, 0x71, 0x2e, 0xad, + 0xa9, 0x07, 0x71, 0xbb, 0xe4, 0xf5, 0x7f, 0x64, 0xf0, 0x48, 0x18, 0x0b, 0xf7, 0x68, 0xc0, 0x9d, + 0x3c, 0x36, 0x6f, 0x46, 0xd8, 0xd8, 0xdd, 0x70, 0x48, 0xdf, 0xc5, 0x11, 0xcd, 0x84, 0x0f, 0x4d, + 0x86, 0xdb, 0xd8, 0x96, 0x70, 0x13, 0x6b, 0xe5, 0xab, 0x3d, 0x5e, 0x31, 0x5f, 0x19, 0x4b, 0x59, + 0x33, 0x62, 0xa6, 0x04, 0x03, 0x16, 0xa3, 0xec, 0xc9, 0x0d, 0x4c, 0xa2, 0x79, 0x8a, 0xa1, 0xe4, + 0xc5, 0x92, 0x9a, 0xa3, 0x05, 0x9e, 0x78, 0xaf, 0xd8, 0x70, 0x7f, 0x91, 0x4d, 0x6c, 0xa7, 0x99, + 0x58, 0xe2, 0x09, 0xce, 0x6a, 0x15, 0xd0, 0x7c, 0x7a, 0x4d, 0x1d, 0x0e, 0xd1, 0x14, 0x37, 0xb4, + 0x13, 0xc4, 0x77, 0xa4, 0xca, 0xa5, 0x7c, 0x94, 0x9e, 0x69, 0x42, 0xb1, 0x52, 0x2a, 0xe7, 0xb0, + 0x95, 0xee, 0x44, 0x1a, 0x4a, 0x7c, 0x3b, 0x1b, 0xfa, 0x2e, 0x7c, 0x72, 0x57, 0x3a, 0x22, 0x74, + 0xf1, 0x10, 0x85, 0x5e, 0xfa, 0x88, 0x3e, 0x16, 0x9e, 0xf5, 0xd8, 0xca, 0x2c, 0x68, 0x61, 0x5d, + 0xf1, 0x07, 0xb2, 0xf9, 0xca, 0xe7, 0xcb, 0x74, 0x41, 0xfd, 0xa7, 0xae, 0xcd, 0x31, 0xee, 0x9f, + 0x8f, 0xd5, 0x44, 0x07, 0x9e, 0x38, 0xfa, 0x2e, 0xfc, 0xf1, 0x2d, 0xc2, 0x57, 0x55, 0xf1, 0xd9, + 0x0f, 0xa1, 0x34, 0x73, 0xe5, 0xe0, 0x1e, 0x9e, 0xbd, 0x73, 0xca, 0xef, 0x25, 0x49, 0xd5, 0xb2, + 0xf2, 0xcc, 0x06, 0x6d, 0xfe, 0xf8, 0xc2, 0x79, 0x9d, 0x39, 0xbf, 0x50, 0xf4, 0x43, 0xd8, 0x8c, + 0x29, 0xc7, 0xcd, 0xee, 0xab, 0x66, 0xfd, 0x84, 0x9c, 0x75, 0xba, 0x87, 0x8d, 0xb2, 0xc2, 0xb5, + 0x8e, 0x99, 0x9b, 0xbf, 0xe8, 0xb4, 0xcb, 0x2a, 0xfe, 0x06, 0x58, 0x8f, 0x49, 0x07, 0xed, 0xd7, + 0x7b, 0x87, 0x07, 0x8d, 0x72, 0xe6, 0xd9, 0x5f, 0x55, 0xd0, 0xe6, 0x37, 0xb7, 0xf6, 0x04, 0xee, + 0xda, 0xe7, 0x68, 0xfe, 0x63, 0x78, 0x9c, 0xc2, 0xd4, 0xaa, 0x93, 0x56, 0xe7, 0xa0, 0xdd, 0x22, + 0x8d, 0xce, 0x59, 0x1b, 0x3d, 0xf9, 0x08, 0x1e, 0xa6, 0x70, 0xb5, 0x3b, 0x63, 0x45, 0xaa, 0xf6, + 0x05, 0x7c, 0x76, 0x2b, 0x0b, 0xfa, 0x4b, 0x0e, 0x3b, 0x2d, 0xfc, 0xf8, 0xf9, 0x69, 0xf3, 0xb4, + 0x59, 0xce, 0x68, 0x8f, 0xe0, 0xc1, 0x02, 0x89, 0x93, 0xe6, 0xde, 0x51, 0x39, 0xab, 0x3d, 0x86, + 0x9d, 0x14, 0x86, 0xde, 0x69, 0xef, 0xb8, 0xd9, 0x6e, 0x34, 0x1b, 0xe5, 0x9c, 0xf6, 0x29, 0x3c, + 0x49, 0xe3, 0xe0, 0xf2, 0xd3, 0x01, 0xe4, 0x5f, 0xe6, 0xf6, 0x95, 0xb7, 0xca, 0x7b, 0xff, 0x0f, + 0x00, 0x00, 0xff, 0xff, 0x28, 0x62, 0x57, 0xd3, 0xe3, 0x14, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/system.pb.go b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/system.pb.go new file mode 100644 index 00000000..bc5b1102 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/dota/protocol/protobuf/system.pb.go @@ -0,0 +1,579 @@ +// Code generated by protoc-gen-go. +// source: gcsystemmsgs.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 protobuf is being compiled against. +const _ = proto.ProtoPackageIsVersion1 + +type EGCSystemMsg int32 + +const ( + EGCSystemMsg_k_EGCMsgInvalid EGCSystemMsg = 0 + EGCSystemMsg_k_EGCMsgMulti EGCSystemMsg = 1 + EGCSystemMsg_k_EGCMsgGenericReply EGCSystemMsg = 10 + EGCSystemMsg_k_EGCMsgSystemBase EGCSystemMsg = 50 + EGCSystemMsg_k_EGCMsgAchievementAwarded EGCSystemMsg = 51 + EGCSystemMsg_k_EGCMsgConCommand EGCSystemMsg = 52 + EGCSystemMsg_k_EGCMsgStartPlaying EGCSystemMsg = 53 + EGCSystemMsg_k_EGCMsgStopPlaying EGCSystemMsg = 54 + EGCSystemMsg_k_EGCMsgStartGameserver EGCSystemMsg = 55 + EGCSystemMsg_k_EGCMsgStopGameserver EGCSystemMsg = 56 + EGCSystemMsg_k_EGCMsgWGRequest EGCSystemMsg = 57 + EGCSystemMsg_k_EGCMsgWGResponse EGCSystemMsg = 58 + EGCSystemMsg_k_EGCMsgGetUserGameStatsSchema EGCSystemMsg = 59 + EGCSystemMsg_k_EGCMsgGetUserGameStatsSchemaResponse EGCSystemMsg = 60 + EGCSystemMsg_k_EGCMsgGetUserStatsDEPRECATED EGCSystemMsg = 61 + EGCSystemMsg_k_EGCMsgGetUserStatsResponse EGCSystemMsg = 62 + EGCSystemMsg_k_EGCMsgAppInfoUpdated EGCSystemMsg = 63 + EGCSystemMsg_k_EGCMsgValidateSession EGCSystemMsg = 64 + EGCSystemMsg_k_EGCMsgValidateSessionResponse EGCSystemMsg = 65 + EGCSystemMsg_k_EGCMsgLookupAccountFromInput EGCSystemMsg = 66 + EGCSystemMsg_k_EGCMsgSendHTTPRequest EGCSystemMsg = 67 + EGCSystemMsg_k_EGCMsgSendHTTPRequestResponse EGCSystemMsg = 68 + EGCSystemMsg_k_EGCMsgPreTestSetup EGCSystemMsg = 69 + EGCSystemMsg_k_EGCMsgRecordSupportAction EGCSystemMsg = 70 + EGCSystemMsg_k_EGCMsgGetAccountDetails_DEPRECATED EGCSystemMsg = 71 + EGCSystemMsg_k_EGCMsgReceiveInterAppMessage EGCSystemMsg = 73 + EGCSystemMsg_k_EGCMsgFindAccounts EGCSystemMsg = 74 + EGCSystemMsg_k_EGCMsgPostAlert EGCSystemMsg = 75 + EGCSystemMsg_k_EGCMsgGetLicenses EGCSystemMsg = 76 + EGCSystemMsg_k_EGCMsgGetUserStats EGCSystemMsg = 77 + EGCSystemMsg_k_EGCMsgGetCommands EGCSystemMsg = 78 + EGCSystemMsg_k_EGCMsgGetCommandsResponse EGCSystemMsg = 79 + EGCSystemMsg_k_EGCMsgAddFreeLicense EGCSystemMsg = 80 + EGCSystemMsg_k_EGCMsgAddFreeLicenseResponse EGCSystemMsg = 81 + EGCSystemMsg_k_EGCMsgGetIPLocation EGCSystemMsg = 82 + EGCSystemMsg_k_EGCMsgGetIPLocationResponse EGCSystemMsg = 83 + EGCSystemMsg_k_EGCMsgSystemStatsSchema EGCSystemMsg = 84 + EGCSystemMsg_k_EGCMsgGetSystemStats EGCSystemMsg = 85 + EGCSystemMsg_k_EGCMsgGetSystemStatsResponse EGCSystemMsg = 86 + EGCSystemMsg_k_EGCMsgSendEmail EGCSystemMsg = 87 + EGCSystemMsg_k_EGCMsgSendEmailResponse EGCSystemMsg = 88 + EGCSystemMsg_k_EGCMsgGetEmailTemplate EGCSystemMsg = 89 + EGCSystemMsg_k_EGCMsgGetEmailTemplateResponse EGCSystemMsg = 90 + EGCSystemMsg_k_EGCMsgGrantGuestPass EGCSystemMsg = 91 + EGCSystemMsg_k_EGCMsgGrantGuestPassResponse EGCSystemMsg = 92 + EGCSystemMsg_k_EGCMsgGetAccountDetails EGCSystemMsg = 93 + EGCSystemMsg_k_EGCMsgGetAccountDetailsResponse EGCSystemMsg = 94 + EGCSystemMsg_k_EGCMsgGetPersonaNames EGCSystemMsg = 95 + EGCSystemMsg_k_EGCMsgGetPersonaNamesResponse EGCSystemMsg = 96 + EGCSystemMsg_k_EGCMsgMultiplexMsg EGCSystemMsg = 97 + EGCSystemMsg_k_EGCMsgWebAPIRegisterInterfaces EGCSystemMsg = 101 + EGCSystemMsg_k_EGCMsgWebAPIJobRequest EGCSystemMsg = 102 + EGCSystemMsg_k_EGCMsgWebAPIJobRequestHttpResponse EGCSystemMsg = 104 + EGCSystemMsg_k_EGCMsgWebAPIJobRequestForwardResponse EGCSystemMsg = 105 + EGCSystemMsg_k_EGCMsgMemCachedGet EGCSystemMsg = 200 + EGCSystemMsg_k_EGCMsgMemCachedGetResponse EGCSystemMsg = 201 + EGCSystemMsg_k_EGCMsgMemCachedSet EGCSystemMsg = 202 + EGCSystemMsg_k_EGCMsgMemCachedDelete EGCSystemMsg = 203 + EGCSystemMsg_k_EGCMsgMemCachedStats EGCSystemMsg = 204 + EGCSystemMsg_k_EGCMsgMemCachedStatsResponse EGCSystemMsg = 205 + EGCSystemMsg_k_EGCMsgSQLStats EGCSystemMsg = 210 + EGCSystemMsg_k_EGCMsgSQLStatsResponse EGCSystemMsg = 211 + EGCSystemMsg_k_EGCMsgMasterSetDirectory EGCSystemMsg = 220 + EGCSystemMsg_k_EGCMsgMasterSetDirectoryResponse EGCSystemMsg = 221 + EGCSystemMsg_k_EGCMsgMasterSetWebAPIRouting EGCSystemMsg = 222 + EGCSystemMsg_k_EGCMsgMasterSetWebAPIRoutingResponse EGCSystemMsg = 223 + EGCSystemMsg_k_EGCMsgMasterSetClientMsgRouting EGCSystemMsg = 224 + EGCSystemMsg_k_EGCMsgMasterSetClientMsgRoutingResponse EGCSystemMsg = 225 + EGCSystemMsg_k_EGCMsgSetOptions EGCSystemMsg = 226 + EGCSystemMsg_k_EGCMsgSetOptionsResponse EGCSystemMsg = 227 + EGCSystemMsg_k_EGCMsgSystemBase2 EGCSystemMsg = 500 + EGCSystemMsg_k_EGCMsgGetPurchaseTrustStatus EGCSystemMsg = 501 + EGCSystemMsg_k_EGCMsgGetPurchaseTrustStatusResponse EGCSystemMsg = 502 + EGCSystemMsg_k_EGCMsgUpdateSession EGCSystemMsg = 503 + EGCSystemMsg_k_EGCMsgGCAccountVacStatusChange EGCSystemMsg = 504 + EGCSystemMsg_k_EGCMsgCheckFriendship EGCSystemMsg = 505 + EGCSystemMsg_k_EGCMsgCheckFriendshipResponse EGCSystemMsg = 506 + EGCSystemMsg_k_EGCMsgGetPartnerAccountLink EGCSystemMsg = 507 + EGCSystemMsg_k_EGCMsgGetPartnerAccountLinkResponse EGCSystemMsg = 508 + EGCSystemMsg_k_EGCMsgVSReportedSuspiciousActivity EGCSystemMsg = 509 + EGCSystemMsg_k_EGCMsgDPPartnerMicroTxns EGCSystemMsg = 512 + EGCSystemMsg_k_EGCMsgDPPartnerMicroTxnsResponse EGCSystemMsg = 513 + EGCSystemMsg_k_EGCMsgGetIPASN EGCSystemMsg = 514 + EGCSystemMsg_k_EGCMsgGetIPASNResponse EGCSystemMsg = 515 + EGCSystemMsg_k_EGCMsgGetAppFriendsList EGCSystemMsg = 516 + EGCSystemMsg_k_EGCMsgGetAppFriendsListResponse EGCSystemMsg = 517 +) + +var EGCSystemMsg_name = map[int32]string{ + 0: "k_EGCMsgInvalid", + 1: "k_EGCMsgMulti", + 10: "k_EGCMsgGenericReply", + 50: "k_EGCMsgSystemBase", + 51: "k_EGCMsgAchievementAwarded", + 52: "k_EGCMsgConCommand", + 53: "k_EGCMsgStartPlaying", + 54: "k_EGCMsgStopPlaying", + 55: "k_EGCMsgStartGameserver", + 56: "k_EGCMsgStopGameserver", + 57: "k_EGCMsgWGRequest", + 58: "k_EGCMsgWGResponse", + 59: "k_EGCMsgGetUserGameStatsSchema", + 60: "k_EGCMsgGetUserGameStatsSchemaResponse", + 61: "k_EGCMsgGetUserStatsDEPRECATED", + 62: "k_EGCMsgGetUserStatsResponse", + 63: "k_EGCMsgAppInfoUpdated", + 64: "k_EGCMsgValidateSession", + 65: "k_EGCMsgValidateSessionResponse", + 66: "k_EGCMsgLookupAccountFromInput", + 67: "k_EGCMsgSendHTTPRequest", + 68: "k_EGCMsgSendHTTPRequestResponse", + 69: "k_EGCMsgPreTestSetup", + 70: "k_EGCMsgRecordSupportAction", + 71: "k_EGCMsgGetAccountDetails_DEPRECATED", + 73: "k_EGCMsgReceiveInterAppMessage", + 74: "k_EGCMsgFindAccounts", + 75: "k_EGCMsgPostAlert", + 76: "k_EGCMsgGetLicenses", + 77: "k_EGCMsgGetUserStats", + 78: "k_EGCMsgGetCommands", + 79: "k_EGCMsgGetCommandsResponse", + 80: "k_EGCMsgAddFreeLicense", + 81: "k_EGCMsgAddFreeLicenseResponse", + 82: "k_EGCMsgGetIPLocation", + 83: "k_EGCMsgGetIPLocationResponse", + 84: "k_EGCMsgSystemStatsSchema", + 85: "k_EGCMsgGetSystemStats", + 86: "k_EGCMsgGetSystemStatsResponse", + 87: "k_EGCMsgSendEmail", + 88: "k_EGCMsgSendEmailResponse", + 89: "k_EGCMsgGetEmailTemplate", + 90: "k_EGCMsgGetEmailTemplateResponse", + 91: "k_EGCMsgGrantGuestPass", + 92: "k_EGCMsgGrantGuestPassResponse", + 93: "k_EGCMsgGetAccountDetails", + 94: "k_EGCMsgGetAccountDetailsResponse", + 95: "k_EGCMsgGetPersonaNames", + 96: "k_EGCMsgGetPersonaNamesResponse", + 97: "k_EGCMsgMultiplexMsg", + 101: "k_EGCMsgWebAPIRegisterInterfaces", + 102: "k_EGCMsgWebAPIJobRequest", + 104: "k_EGCMsgWebAPIJobRequestHttpResponse", + 105: "k_EGCMsgWebAPIJobRequestForwardResponse", + 200: "k_EGCMsgMemCachedGet", + 201: "k_EGCMsgMemCachedGetResponse", + 202: "k_EGCMsgMemCachedSet", + 203: "k_EGCMsgMemCachedDelete", + 204: "k_EGCMsgMemCachedStats", + 205: "k_EGCMsgMemCachedStatsResponse", + 210: "k_EGCMsgSQLStats", + 211: "k_EGCMsgSQLStatsResponse", + 220: "k_EGCMsgMasterSetDirectory", + 221: "k_EGCMsgMasterSetDirectoryResponse", + 222: "k_EGCMsgMasterSetWebAPIRouting", + 223: "k_EGCMsgMasterSetWebAPIRoutingResponse", + 224: "k_EGCMsgMasterSetClientMsgRouting", + 225: "k_EGCMsgMasterSetClientMsgRoutingResponse", + 226: "k_EGCMsgSetOptions", + 227: "k_EGCMsgSetOptionsResponse", + 500: "k_EGCMsgSystemBase2", + 501: "k_EGCMsgGetPurchaseTrustStatus", + 502: "k_EGCMsgGetPurchaseTrustStatusResponse", + 503: "k_EGCMsgUpdateSession", + 504: "k_EGCMsgGCAccountVacStatusChange", + 505: "k_EGCMsgCheckFriendship", + 506: "k_EGCMsgCheckFriendshipResponse", + 507: "k_EGCMsgGetPartnerAccountLink", + 508: "k_EGCMsgGetPartnerAccountLinkResponse", + 509: "k_EGCMsgVSReportedSuspiciousActivity", + 512: "k_EGCMsgDPPartnerMicroTxns", + 513: "k_EGCMsgDPPartnerMicroTxnsResponse", + 514: "k_EGCMsgGetIPASN", + 515: "k_EGCMsgGetIPASNResponse", + 516: "k_EGCMsgGetAppFriendsList", + 517: "k_EGCMsgGetAppFriendsListResponse", +} +var EGCSystemMsg_value = map[string]int32{ + "k_EGCMsgInvalid": 0, + "k_EGCMsgMulti": 1, + "k_EGCMsgGenericReply": 10, + "k_EGCMsgSystemBase": 50, + "k_EGCMsgAchievementAwarded": 51, + "k_EGCMsgConCommand": 52, + "k_EGCMsgStartPlaying": 53, + "k_EGCMsgStopPlaying": 54, + "k_EGCMsgStartGameserver": 55, + "k_EGCMsgStopGameserver": 56, + "k_EGCMsgWGRequest": 57, + "k_EGCMsgWGResponse": 58, + "k_EGCMsgGetUserGameStatsSchema": 59, + "k_EGCMsgGetUserGameStatsSchemaResponse": 60, + "k_EGCMsgGetUserStatsDEPRECATED": 61, + "k_EGCMsgGetUserStatsResponse": 62, + "k_EGCMsgAppInfoUpdated": 63, + "k_EGCMsgValidateSession": 64, + "k_EGCMsgValidateSessionResponse": 65, + "k_EGCMsgLookupAccountFromInput": 66, + "k_EGCMsgSendHTTPRequest": 67, + "k_EGCMsgSendHTTPRequestResponse": 68, + "k_EGCMsgPreTestSetup": 69, + "k_EGCMsgRecordSupportAction": 70, + "k_EGCMsgGetAccountDetails_DEPRECATED": 71, + "k_EGCMsgReceiveInterAppMessage": 73, + "k_EGCMsgFindAccounts": 74, + "k_EGCMsgPostAlert": 75, + "k_EGCMsgGetLicenses": 76, + "k_EGCMsgGetUserStats": 77, + "k_EGCMsgGetCommands": 78, + "k_EGCMsgGetCommandsResponse": 79, + "k_EGCMsgAddFreeLicense": 80, + "k_EGCMsgAddFreeLicenseResponse": 81, + "k_EGCMsgGetIPLocation": 82, + "k_EGCMsgGetIPLocationResponse": 83, + "k_EGCMsgSystemStatsSchema": 84, + "k_EGCMsgGetSystemStats": 85, + "k_EGCMsgGetSystemStatsResponse": 86, + "k_EGCMsgSendEmail": 87, + "k_EGCMsgSendEmailResponse": 88, + "k_EGCMsgGetEmailTemplate": 89, + "k_EGCMsgGetEmailTemplateResponse": 90, + "k_EGCMsgGrantGuestPass": 91, + "k_EGCMsgGrantGuestPassResponse": 92, + "k_EGCMsgGetAccountDetails": 93, + "k_EGCMsgGetAccountDetailsResponse": 94, + "k_EGCMsgGetPersonaNames": 95, + "k_EGCMsgGetPersonaNamesResponse": 96, + "k_EGCMsgMultiplexMsg": 97, + "k_EGCMsgWebAPIRegisterInterfaces": 101, + "k_EGCMsgWebAPIJobRequest": 102, + "k_EGCMsgWebAPIJobRequestHttpResponse": 104, + "k_EGCMsgWebAPIJobRequestForwardResponse": 105, + "k_EGCMsgMemCachedGet": 200, + "k_EGCMsgMemCachedGetResponse": 201, + "k_EGCMsgMemCachedSet": 202, + "k_EGCMsgMemCachedDelete": 203, + "k_EGCMsgMemCachedStats": 204, + "k_EGCMsgMemCachedStatsResponse": 205, + "k_EGCMsgSQLStats": 210, + "k_EGCMsgSQLStatsResponse": 211, + "k_EGCMsgMasterSetDirectory": 220, + "k_EGCMsgMasterSetDirectoryResponse": 221, + "k_EGCMsgMasterSetWebAPIRouting": 222, + "k_EGCMsgMasterSetWebAPIRoutingResponse": 223, + "k_EGCMsgMasterSetClientMsgRouting": 224, + "k_EGCMsgMasterSetClientMsgRoutingResponse": 225, + "k_EGCMsgSetOptions": 226, + "k_EGCMsgSetOptionsResponse": 227, + "k_EGCMsgSystemBase2": 500, + "k_EGCMsgGetPurchaseTrustStatus": 501, + "k_EGCMsgGetPurchaseTrustStatusResponse": 502, + "k_EGCMsgUpdateSession": 503, + "k_EGCMsgGCAccountVacStatusChange": 504, + "k_EGCMsgCheckFriendship": 505, + "k_EGCMsgCheckFriendshipResponse": 506, + "k_EGCMsgGetPartnerAccountLink": 507, + "k_EGCMsgGetPartnerAccountLinkResponse": 508, + "k_EGCMsgVSReportedSuspiciousActivity": 509, + "k_EGCMsgDPPartnerMicroTxns": 512, + "k_EGCMsgDPPartnerMicroTxnsResponse": 513, + "k_EGCMsgGetIPASN": 514, + "k_EGCMsgGetIPASNResponse": 515, + "k_EGCMsgGetAppFriendsList": 516, + "k_EGCMsgGetAppFriendsListResponse": 517, +} + +func (x EGCSystemMsg) Enum() *EGCSystemMsg { + p := new(EGCSystemMsg) + *p = x + return p +} +func (x EGCSystemMsg) String() string { + return proto.EnumName(EGCSystemMsg_name, int32(x)) +} +func (x *EGCSystemMsg) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCSystemMsg_value, data, "EGCSystemMsg") + if err != nil { + return err + } + *x = EGCSystemMsg(value) + return nil +} +func (EGCSystemMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{0} } + +type ESOMsg int32 + +const ( + ESOMsg_k_ESOMsg_Create ESOMsg = 21 + ESOMsg_k_ESOMsg_Update ESOMsg = 22 + ESOMsg_k_ESOMsg_Destroy ESOMsg = 23 + ESOMsg_k_ESOMsg_CacheSubscribed ESOMsg = 24 + ESOMsg_k_ESOMsg_CacheUnsubscribed ESOMsg = 25 + ESOMsg_k_ESOMsg_UpdateMultiple ESOMsg = 26 + ESOMsg_k_ESOMsg_CacheSubscriptionRefresh ESOMsg = 28 + ESOMsg_k_ESOMsg_CacheSubscribedUpToDate ESOMsg = 29 +) + +var ESOMsg_name = map[int32]string{ + 21: "k_ESOMsg_Create", + 22: "k_ESOMsg_Update", + 23: "k_ESOMsg_Destroy", + 24: "k_ESOMsg_CacheSubscribed", + 25: "k_ESOMsg_CacheUnsubscribed", + 26: "k_ESOMsg_UpdateMultiple", + 28: "k_ESOMsg_CacheSubscriptionRefresh", + 29: "k_ESOMsg_CacheSubscribedUpToDate", +} +var ESOMsg_value = map[string]int32{ + "k_ESOMsg_Create": 21, + "k_ESOMsg_Update": 22, + "k_ESOMsg_Destroy": 23, + "k_ESOMsg_CacheSubscribed": 24, + "k_ESOMsg_CacheUnsubscribed": 25, + "k_ESOMsg_UpdateMultiple": 26, + "k_ESOMsg_CacheSubscriptionRefresh": 28, + "k_ESOMsg_CacheSubscribedUpToDate": 29, +} + +func (x ESOMsg) Enum() *ESOMsg { + p := new(ESOMsg) + *p = x + return p +} +func (x ESOMsg) String() string { + return proto.EnumName(ESOMsg_name, int32(x)) +} +func (x *ESOMsg) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ESOMsg_value, data, "ESOMsg") + if err != nil { + return err + } + *x = ESOMsg(value) + return nil +} +func (ESOMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{1} } + +type EGCBaseClientMsg int32 + +const ( + EGCBaseClientMsg_k_EMsgGCPingRequest EGCBaseClientMsg = 3001 + EGCBaseClientMsg_k_EMsgGCPingResponse EGCBaseClientMsg = 3002 + EGCBaseClientMsg_k_EMsgGCClientWelcome EGCBaseClientMsg = 4004 + EGCBaseClientMsg_k_EMsgGCServerWelcome EGCBaseClientMsg = 4005 + EGCBaseClientMsg_k_EMsgGCClientHello EGCBaseClientMsg = 4006 + EGCBaseClientMsg_k_EMsgGCServerHello EGCBaseClientMsg = 4007 + EGCBaseClientMsg_k_EMsgGCClientConnectionStatus EGCBaseClientMsg = 4009 + EGCBaseClientMsg_k_EMsgGCServerConnectionStatus EGCBaseClientMsg = 4010 +) + +var EGCBaseClientMsg_name = map[int32]string{ + 3001: "k_EMsgGCPingRequest", + 3002: "k_EMsgGCPingResponse", + 4004: "k_EMsgGCClientWelcome", + 4005: "k_EMsgGCServerWelcome", + 4006: "k_EMsgGCClientHello", + 4007: "k_EMsgGCServerHello", + 4009: "k_EMsgGCClientConnectionStatus", + 4010: "k_EMsgGCServerConnectionStatus", +} +var EGCBaseClientMsg_value = map[string]int32{ + "k_EMsgGCPingRequest": 3001, + "k_EMsgGCPingResponse": 3002, + "k_EMsgGCClientWelcome": 4004, + "k_EMsgGCServerWelcome": 4005, + "k_EMsgGCClientHello": 4006, + "k_EMsgGCServerHello": 4007, + "k_EMsgGCClientConnectionStatus": 4009, + "k_EMsgGCServerConnectionStatus": 4010, +} + +func (x EGCBaseClientMsg) Enum() *EGCBaseClientMsg { + p := new(EGCBaseClientMsg) + *p = x + return p +} +func (x EGCBaseClientMsg) String() string { + return proto.EnumName(EGCBaseClientMsg_name, int32(x)) +} +func (x *EGCBaseClientMsg) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCBaseClientMsg_value, data, "EGCBaseClientMsg") + if err != nil { + return err + } + *x = EGCBaseClientMsg(value) + return nil +} +func (EGCBaseClientMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{2} } + +type EGCToGCMsg int32 + +const ( + EGCToGCMsg_k_EGCToGCMsgMasterAck EGCToGCMsg = 150 + EGCToGCMsg_k_EGCToGCMsgMasterAckResponse EGCToGCMsg = 151 + EGCToGCMsg_k_EGCToGCMsgRouted EGCToGCMsg = 152 + EGCToGCMsg_k_EGCToGCMsgRoutedReply EGCToGCMsg = 153 + EGCToGCMsg_k_EMsgGCUpdateSubGCSessionInfo EGCToGCMsg = 154 + EGCToGCMsg_k_EMsgGCRequestSubGCSessionInfo EGCToGCMsg = 155 + EGCToGCMsg_k_EMsgGCRequestSubGCSessionInfoResponse EGCToGCMsg = 156 + EGCToGCMsg_k_EGCToGCMsgMasterStartupComplete EGCToGCMsg = 157 + EGCToGCMsg_k_EMsgGCToGCSOCacheSubscribe EGCToGCMsg = 158 + EGCToGCMsg_k_EMsgGCToGCSOCacheUnsubscribe EGCToGCMsg = 159 + EGCToGCMsg_k_EMsgGCToGCLoadSessionSOCache EGCToGCMsg = 160 + EGCToGCMsg_k_EMsgGCToGCLoadSessionSOCacheResponse EGCToGCMsg = 161 + EGCToGCMsg_k_EMsgGCToGCUpdateSessionStats EGCToGCMsg = 162 +) + +var EGCToGCMsg_name = map[int32]string{ + 150: "k_EGCToGCMsgMasterAck", + 151: "k_EGCToGCMsgMasterAckResponse", + 152: "k_EGCToGCMsgRouted", + 153: "k_EGCToGCMsgRoutedReply", + 154: "k_EMsgGCUpdateSubGCSessionInfo", + 155: "k_EMsgGCRequestSubGCSessionInfo", + 156: "k_EMsgGCRequestSubGCSessionInfoResponse", + 157: "k_EGCToGCMsgMasterStartupComplete", + 158: "k_EMsgGCToGCSOCacheSubscribe", + 159: "k_EMsgGCToGCSOCacheUnsubscribe", + 160: "k_EMsgGCToGCLoadSessionSOCache", + 161: "k_EMsgGCToGCLoadSessionSOCacheResponse", + 162: "k_EMsgGCToGCUpdateSessionStats", +} +var EGCToGCMsg_value = map[string]int32{ + "k_EGCToGCMsgMasterAck": 150, + "k_EGCToGCMsgMasterAckResponse": 151, + "k_EGCToGCMsgRouted": 152, + "k_EGCToGCMsgRoutedReply": 153, + "k_EMsgGCUpdateSubGCSessionInfo": 154, + "k_EMsgGCRequestSubGCSessionInfo": 155, + "k_EMsgGCRequestSubGCSessionInfoResponse": 156, + "k_EGCToGCMsgMasterStartupComplete": 157, + "k_EMsgGCToGCSOCacheSubscribe": 158, + "k_EMsgGCToGCSOCacheUnsubscribe": 159, + "k_EMsgGCToGCLoadSessionSOCache": 160, + "k_EMsgGCToGCLoadSessionSOCacheResponse": 161, + "k_EMsgGCToGCUpdateSessionStats": 162, +} + +func (x EGCToGCMsg) Enum() *EGCToGCMsg { + p := new(EGCToGCMsg) + *p = x + return p +} +func (x EGCToGCMsg) String() string { + return proto.EnumName(EGCToGCMsg_name, int32(x)) +} +func (x *EGCToGCMsg) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EGCToGCMsg_value, data, "EGCToGCMsg") + if err != nil { + return err + } + *x = EGCToGCMsg(value) + return nil +} +func (EGCToGCMsg) EnumDescriptor() ([]byte, []int) { return system_fileDescriptor0, []int{3} } + +func init() { + proto.RegisterEnum("EGCSystemMsg", EGCSystemMsg_name, EGCSystemMsg_value) + proto.RegisterEnum("ESOMsg", ESOMsg_name, ESOMsg_value) + proto.RegisterEnum("EGCBaseClientMsg", EGCBaseClientMsg_name, EGCBaseClientMsg_value) + proto.RegisterEnum("EGCToGCMsg", EGCToGCMsg_name, EGCToGCMsg_value) +} + +var system_fileDescriptor0 = []byte{ + // 1475 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x57, 0x59, 0x73, 0x1b, 0xc5, + 0x13, 0xcf, 0x96, 0xfc, 0xff, 0x3f, 0x4c, 0x41, 0xd1, 0x99, 0xc4, 0x47, 0x12, 0x27, 0x4a, 0x42, + 0x0e, 0x62, 0xa8, 0x3c, 0x84, 0xfb, 0x46, 0x91, 0x64, 0x5b, 0x41, 0x8e, 0x15, 0x4b, 0xb6, 0xb9, + 0xcd, 0x7a, 0x35, 0xb6, 0xb6, 0x2c, 0xed, 0x2c, 0x33, 0xbb, 0x26, 0x7e, 0x0b, 0xd7, 0x57, 0xe0, + 0xbe, 0x8b, 0xa3, 0xe0, 0x1b, 0xc0, 0x27, 0xe0, 0x7c, 0x81, 0x57, 0xee, 0x7c, 0x01, 0x1e, 0xb8, + 0x21, 0x55, 0xf4, 0xee, 0xce, 0xce, 0xce, 0x4a, 0xb2, 0x79, 0x93, 0xe6, 0xd7, 0xdd, 0xd3, 0xdd, + 0xd3, 0xfd, 0xeb, 0x5e, 0x42, 0xd7, 0x1d, 0xb9, 0x25, 0x03, 0xd6, 0xeb, 0xc9, 0x75, 0x79, 0xda, + 0x17, 0x3c, 0xe0, 0x53, 0x97, 0x47, 0xc9, 0x55, 0xd5, 0x99, 0x72, 0x33, 0x3e, 0x9f, 0x93, 0xeb, + 0x74, 0x0f, 0xb9, 0x66, 0x63, 0x05, 0x4f, 0xf0, 0x77, 0xcd, 0xdb, 0xb4, 0xbb, 0x6e, 0x1b, 0x76, + 0xd1, 0xdd, 0xe4, 0xea, 0xf4, 0x70, 0x2e, 0xec, 0x06, 0x2e, 0x58, 0x74, 0x82, 0xec, 0x4d, 0x8f, + 0x66, 0x98, 0xc7, 0x84, 0xeb, 0x2c, 0x30, 0xbf, 0xbb, 0x05, 0x84, 0x8e, 0x11, 0x9a, 0x22, 0x89, + 0xd9, 0xb3, 0xb6, 0x64, 0x70, 0x86, 0x1e, 0x22, 0xfb, 0xd3, 0xf3, 0x92, 0xd3, 0x71, 0xd9, 0x26, + 0xeb, 0x31, 0x2f, 0x28, 0x3d, 0x69, 0x8b, 0x36, 0x6b, 0xc3, 0x8d, 0xa6, 0x5e, 0x99, 0x7b, 0x65, + 0xde, 0xeb, 0xd9, 0x5e, 0x1b, 0x6e, 0x32, 0x6f, 0x6a, 0x06, 0xb6, 0x08, 0x1a, 0x5d, 0x7b, 0xcb, + 0xf5, 0xd6, 0xe1, 0x66, 0x3a, 0x4e, 0xf6, 0x64, 0x08, 0xf7, 0x53, 0xe0, 0x16, 0x7a, 0x80, 0x8c, + 0xe7, 0x54, 0x66, 0xec, 0x1e, 0x93, 0x4c, 0x6c, 0x32, 0x01, 0xb7, 0xd2, 0xfd, 0x64, 0xcc, 0xd4, + 0x32, 0xb0, 0xdb, 0xe8, 0x28, 0xd9, 0x9d, 0x62, 0xcb, 0x33, 0x0b, 0xec, 0x89, 0x90, 0xc9, 0x00, + 0x6e, 0x37, 0x5d, 0x8b, 0x8e, 0xa5, 0xcf, 0x3d, 0x0c, 0xe9, 0x0e, 0x7a, 0x94, 0x1c, 0xca, 0x92, + 0x10, 0x2c, 0xa2, 0x99, 0xc8, 0x1a, 0x5e, 0x19, 0xc8, 0xa6, 0xd3, 0x61, 0x3d, 0x1b, 0xee, 0xa4, + 0x53, 0xe4, 0xc4, 0xce, 0x32, 0xda, 0xde, 0x5d, 0x43, 0xec, 0xc5, 0x72, 0x95, 0x6a, 0x63, 0xa1, + 0x5a, 0x2e, 0xb5, 0xaa, 0x15, 0xb8, 0x9b, 0x1e, 0x26, 0x93, 0xc3, 0x64, 0xb4, 0x95, 0x7b, 0xcc, + 0x00, 0x4b, 0xbe, 0x5f, 0xf3, 0xd6, 0xf8, 0xa2, 0xdf, 0xb6, 0x03, 0x4c, 0xf2, 0xbd, 0x66, 0x66, + 0x96, 0xa2, 0xc7, 0xc5, 0xe3, 0x26, 0x93, 0xd2, 0xe5, 0x1e, 0xdc, 0x47, 0xaf, 0x25, 0xc5, 0x6d, + 0x40, 0x6d, 0xbd, 0x64, 0xfa, 0x58, 0xe7, 0x7c, 0x23, 0xf4, 0x4b, 0x8e, 0xc3, 0x43, 0x2f, 0x98, + 0x16, 0xbc, 0x57, 0xf3, 0xfc, 0x30, 0x80, 0xb3, 0xb9, 0xfc, 0x33, 0xaf, 0x3d, 0xdb, 0x6a, 0x35, + 0xd2, 0x64, 0x96, 0xcd, 0x5b, 0xfa, 0x40, 0x7d, 0x4b, 0xc5, 0x7c, 0xf4, 0x86, 0x60, 0x2d, 0x04, + 0x9b, 0x2c, 0x08, 0x7d, 0xa8, 0xd2, 0x22, 0x39, 0x90, 0x22, 0x0b, 0xcc, 0xe1, 0xa2, 0xdd, 0x0c, + 0x7d, 0x9f, 0x8b, 0xa0, 0xe4, 0x04, 0x51, 0x14, 0xd3, 0xf4, 0x3a, 0x72, 0xcc, 0x48, 0x90, 0xf2, + 0xae, 0xc2, 0x02, 0xdb, 0xed, 0xca, 0x15, 0x23, 0x95, 0x33, 0x66, 0x28, 0x68, 0x8a, 0xb9, 0x9b, + 0xac, 0xe6, 0x05, 0x4c, 0x60, 0xd2, 0xe6, 0x30, 0x6c, 0x7b, 0x9d, 0x41, 0xcd, 0x74, 0x64, 0xda, + 0xf5, 0xda, 0xca, 0x9c, 0x84, 0x73, 0x66, 0xad, 0x34, 0xb8, 0x0c, 0x4a, 0x5d, 0x26, 0x02, 0xb8, + 0xdf, 0x2c, 0x4a, 0xbc, 0xbe, 0xee, 0x3a, 0x0c, 0x23, 0x92, 0x50, 0xcf, 0x77, 0x4c, 0xf6, 0x70, + 0x30, 0xd7, 0xa7, 0xa2, 0x2a, 0x5f, 0xc2, 0x79, 0x33, 0x56, 0x03, 0xd0, 0x69, 0x9a, 0xcf, 0x3d, + 0x75, 0xbb, 0x3d, 0x2d, 0x18, 0x53, 0x17, 0x42, 0xc3, 0x8c, 0x2e, 0x8f, 0x69, 0xfd, 0x0b, 0x74, + 0x1f, 0x19, 0x35, 0x2e, 0xa8, 0x35, 0xea, 0xdc, 0xb1, 0xe3, 0x34, 0x2e, 0xd0, 0x23, 0xe4, 0xe0, + 0x50, 0x48, 0x6b, 0x37, 0xe9, 0x41, 0xb2, 0x2f, 0xdf, 0xe9, 0x66, 0xe5, 0xb7, 0x4c, 0xe7, 0xd0, + 0x82, 0x21, 0x01, 0x8b, 0x7d, 0x95, 0x6e, 0x60, 0xda, 0xfc, 0x92, 0x99, 0xe0, 0xa8, 0x50, 0xaa, + 0x3d, 0x7c, 0x41, 0x58, 0xce, 0xdd, 0x9a, 0x1e, 0x6b, 0xad, 0x07, 0xe8, 0x24, 0x99, 0x30, 0x2c, + 0xc7, 0x68, 0x8b, 0xf5, 0xfc, 0x2e, 0x16, 0x33, 0x3c, 0x48, 0x8f, 0x91, 0xc3, 0xdb, 0xa1, 0xda, + 0xc6, 0x43, 0x39, 0xcf, 0x85, 0xed, 0x05, 0x33, 0x51, 0x75, 0x36, 0x6c, 0x29, 0xe1, 0xe1, 0x9c, + 0xe7, 0x39, 0x4c, 0xeb, 0x3f, 0x62, 0xba, 0x38, 0x50, 0x82, 0xf0, 0x28, 0x3d, 0x4e, 0x8e, 0x6c, + 0x0b, 0x6b, 0x2b, 0x8f, 0x99, 0x5d, 0x84, 0x62, 0x0d, 0x26, 0x24, 0xf7, 0xec, 0xf3, 0x11, 0x5d, + 0xc1, 0x8a, 0xd9, 0x45, 0x7d, 0xa0, 0xb6, 0xf0, 0xb8, 0x59, 0x72, 0x31, 0x6f, 0xfb, 0x5d, 0x76, + 0x11, 0x7f, 0x83, 0x6d, 0xe6, 0x61, 0x99, 0xad, 0x96, 0x1a, 0xb5, 0x05, 0xb6, 0xee, 0xe2, 0x23, + 0x88, 0xb8, 0x03, 0xd6, 0x6c, 0x07, 0x2f, 0x61, 0x66, 0x2e, 0x13, 0xa9, 0x73, 0x7c, 0x35, 0x6d, + 0xe4, 0x35, 0xb3, 0xd1, 0xfa, 0xd1, 0xd9, 0x20, 0xf0, 0xb5, 0x1f, 0x1d, 0x7a, 0x3d, 0x39, 0xb9, + 0x9d, 0xe4, 0x34, 0x17, 0xd1, 0x04, 0xd0, 0xc2, 0x2e, 0xd6, 0x64, 0xe6, 0x34, 0xeb, 0x95, 0x6d, + 0x2c, 0xa7, 0x36, 0x86, 0x08, 0x9f, 0x58, 0x58, 0x93, 0x93, 0xc3, 0x20, 0xad, 0xfc, 0xa9, 0x35, + 0x54, 0x1b, 0xa9, 0x03, 0x3e, 0xb3, 0x30, 0x9a, 0xf1, 0x01, 0xa8, 0xc2, 0xba, 0x0c, 0x0b, 0xe3, + 0x73, 0x0b, 0xb3, 0x3d, 0x36, 0xa8, 0x18, 0x57, 0xeb, 0x17, 0x16, 0x66, 0xfb, 0xd0, 0x70, 0x50, + 0x5f, 0xfd, 0xa5, 0x85, 0xf5, 0x0a, 0xba, 0x30, 0x2f, 0xd4, 0x13, 0xdd, 0xaf, 0x2c, 0x2c, 0x86, + 0x89, 0xfe, 0x63, 0xad, 0xf5, 0xb5, 0x85, 0x3d, 0xae, 0xc7, 0xe2, 0x9c, 0x1d, 0xbd, 0x00, 0x7a, + 0x5b, 0x71, 0x05, 0x73, 0x02, 0x2e, 0xb6, 0xe0, 0x1b, 0x8b, 0x9e, 0x24, 0x47, 0xb7, 0x17, 0xd0, + 0x96, 0xbe, 0xcd, 0x3b, 0x99, 0x0a, 0xaa, 0xc7, 0xe5, 0x61, 0x10, 0x4d, 0xc6, 0xef, 0x2c, 0x7c, + 0x8a, 0x13, 0x3b, 0x0b, 0x69, 0x8b, 0xdf, 0x5b, 0xf4, 0x44, 0x56, 0xa8, 0x5a, 0xb8, 0xdc, 0x75, + 0x71, 0x6c, 0x47, 0x94, 0xa9, 0x8c, 0xfe, 0x60, 0xd1, 0xd3, 0xe4, 0xd4, 0x7f, 0xca, 0x69, 0xbb, + 0x3f, 0x5a, 0x48, 0x78, 0xd9, 0x8a, 0xc0, 0x82, 0x79, 0x3f, 0xe2, 0x15, 0x09, 0x3f, 0xe5, 0x92, + 0x91, 0x01, 0x5a, 0xf3, 0x72, 0xb4, 0x76, 0xec, 0x19, 0x5c, 0x2e, 0xce, 0xc0, 0x2f, 0x05, 0x33, + 0xfa, 0xa8, 0x21, 0x42, 0xe1, 0x74, 0x10, 0x6a, 0x89, 0x10, 0x47, 0x07, 0xe6, 0x3c, 0x94, 0xf0, + 0x6b, 0xc1, 0x8c, 0x7e, 0xb8, 0x90, 0xbe, 0xeb, 0xb7, 0x02, 0xb2, 0x80, 0x26, 0xc7, 0x64, 0x80, + 0xa6, 0x93, 0xf2, 0xf7, 0x02, 0xb6, 0x70, 0xc6, 0x23, 0x65, 0xd5, 0xc1, 0x4b, 0xb6, 0x93, 0x18, + 0x29, 0x77, 0x6c, 0x0f, 0x87, 0xc7, 0x1f, 0x05, 0xb3, 0xe4, 0xca, 0x1d, 0xe6, 0x6c, 0x4c, 0x0b, + 0x4c, 0x4a, 0x5b, 0x76, 0x5c, 0x1f, 0xfe, 0x2c, 0x60, 0x13, 0x16, 0xb7, 0x41, 0xb5, 0x1b, 0x7f, + 0x15, 0x90, 0x70, 0x4c, 0x22, 0x6e, 0xe0, 0x3a, 0x83, 0xeb, 0x96, 0xba, 0xb2, 0xee, 0x7a, 0x1b, + 0xf0, 0x77, 0x01, 0x97, 0x8c, 0xe3, 0x3b, 0xca, 0x68, 0x7b, 0xff, 0x14, 0xe8, 0xa9, 0xac, 0x6d, + 0x97, 0x9a, 0xb8, 0xb4, 0xe1, 0xec, 0xc4, 0x62, 0x0e, 0xa5, 0xef, 0x3a, 0x2e, 0x0f, 0x65, 0x34, + 0x47, 0x37, 0xdd, 0x60, 0x0b, 0xae, 0x14, 0xcc, 0xe7, 0xa8, 0x34, 0x94, 0xd5, 0x39, 0xd7, 0x11, + 0xbc, 0x75, 0x11, 0xdf, 0xeb, 0xd2, 0x88, 0x59, 0x9b, 0x83, 0x02, 0xfa, 0xd2, 0xa7, 0x46, 0xcc, + 0xde, 0x88, 0xa7, 0x49, 0xa9, 0x79, 0x1e, 0x9e, 0x1e, 0x31, 0x7b, 0x23, 0x3d, 0xd6, 0x5a, 0xcf, + 0x8c, 0xe0, 0xca, 0x98, 0xe3, 0x51, 0xdf, 0x57, 0x19, 0xaa, 0x23, 0x55, 0xc1, 0xb3, 0x23, 0x66, + 0x7d, 0x0e, 0xe0, 0xda, 0xce, 0x73, 0x23, 0x53, 0x3f, 0x5b, 0xe4, 0xff, 0xd5, 0xe6, 0x7c, 0xb6, + 0xdf, 0xc6, 0xbf, 0x57, 0xca, 0x82, 0x45, 0x53, 0x61, 0x34, 0x77, 0x98, 0x3c, 0x35, 0x8c, 0xd1, + 0xbd, 0xb1, 0xcb, 0xc9, 0x61, 0x05, 0x99, 0x4a, 0xf0, 0x2d, 0x18, 0x57, 0x94, 0xa8, 0xf4, 0x23, + 0x1e, 0x68, 0x86, 0xab, 0xd2, 0x11, 0xee, 0x2a, 0xae, 0x57, 0x13, 0x6a, 0xc7, 0x35, 0xd0, 0x45, + 0x4f, 0x66, 0xf8, 0x3e, 0x45, 0xe9, 0xe6, 0x45, 0x29, 0x2f, 0xc3, 0x7e, 0x35, 0x16, 0x06, 0x4d, + 0xfb, 0xc9, 0xd8, 0x5d, 0x13, 0x4c, 0x76, 0x60, 0x52, 0x51, 0xf7, 0x50, 0x0f, 0x16, 0xfd, 0x16, + 0xaf, 0x44, 0xde, 0x1f, 0x9c, 0xba, 0x62, 0x11, 0xc0, 0xcc, 0x44, 0xed, 0xa1, 0x3b, 0x51, 0x75, + 0x4f, 0x5c, 0xb3, 0x8d, 0xb8, 0x25, 0x13, 0x2a, 0xff, 0x68, 0x5c, 0xd1, 0xa6, 0x81, 0xa8, 0xe4, + 0x7d, 0x3c, 0xae, 0xda, 0x20, 0x86, 0x12, 0x4b, 0xcb, 0xac, 0xeb, 0xf0, 0x1e, 0x83, 0x77, 0x8a, + 0x26, 0xd6, 0x8c, 0x77, 0xe8, 0x14, 0x7b, 0xb7, 0x68, 0x5e, 0x96, 0xe8, 0xcd, 0xb2, 0x6e, 0x97, + 0xc3, 0x7b, 0x39, 0x24, 0xd1, 0x4a, 0x90, 0xf7, 0x8b, 0xaa, 0x89, 0x0d, 0x1d, 0xfc, 0x12, 0xf0, + 0x58, 0xbc, 0xd9, 0xa9, 0x26, 0xfe, 0x20, 0x27, 0x94, 0xa8, 0x0f, 0x08, 0x7d, 0x58, 0x9c, 0xba, + 0x5c, 0x20, 0x04, 0xe3, 0x6f, 0xf1, 0xb8, 0x3a, 0x74, 0x2f, 0xab, 0xff, 0x09, 0x4b, 0x95, 0x9c, + 0x0d, 0x78, 0xde, 0xd2, 0x0d, 0xd6, 0x8f, 0xe9, 0x24, 0xbc, 0x90, 0x31, 0x96, 0x92, 0x89, 0x38, + 0x0d, 0x1f, 0xf4, 0xc5, 0x6c, 0xa8, 0xe4, 0x80, 0xe4, 0x53, 0xe8, 0x25, 0xcb, 0x74, 0x55, 0x51, + 0x48, 0xb8, 0x1a, 0x79, 0x1d, 0xf3, 0x48, 0xb4, 0x99, 0xc3, 0xcb, 0x96, 0xa2, 0x81, 0x58, 0x48, + 0xbd, 0xc8, 0x80, 0xd4, 0x2b, 0x16, 0xbd, 0x21, 0x9e, 0xa1, 0x3b, 0x49, 0x69, 0x7f, 0x5f, 0xcd, + 0x98, 0x3b, 0x17, 0x53, 0xfc, 0x2d, 0x14, 0xfa, 0xb8, 0x47, 0xfa, 0xf1, 0xd4, 0x7b, 0x2d, 0x9d, + 0xa8, 0xb1, 0xd5, 0x48, 0xb4, 0x39, 0x9f, 0xaf, 0x28, 0x78, 0x3d, 0x17, 0x83, 0x21, 0x62, 0x14, + 0x36, 0xbc, 0x31, 0x20, 0x54, 0xe7, 0x76, 0x5b, 0x79, 0xa6, 0xe4, 0xe1, 0xcd, 0x74, 0xf6, 0xec, + 0x20, 0xa4, 0x23, 0x78, 0x6b, 0xc0, 0x62, 0x8e, 0x81, 0x93, 0xd9, 0xfa, 0xb6, 0x75, 0xf6, 0x7f, + 0xb3, 0xd6, 0x25, 0x6b, 0xd7, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x05, 0xab, 0xaf, 0x14, 0xda, + 0x0e, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory.go b/vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory.go new file mode 100644 index 00000000..93ae9efa --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory.go @@ -0,0 +1,188 @@ +/* +Includes inventory types as used in the trade package +*/ +package inventory + +import ( + "bytes" + "encoding/json" + "fmt" + "github.com/Philipp15b/go-steam/jsont" + "strconv" +) + +type GenericInventory map[uint32]map[uint64]*Inventory + +func NewGenericInventory() GenericInventory { + iMap := make(map[uint32]map[uint64]*Inventory) + return GenericInventory(iMap) +} + +// Get inventory for specified AppId and ContextId +func (i *GenericInventory) Get(appId uint32, contextId uint64) (*Inventory, error) { + iMap := (map[uint32]map[uint64]*Inventory)(*i) + iMap2, ok := iMap[appId] + if !ok { + return nil, fmt.Errorf("inventory for specified appId not found") + } + inv, ok := iMap2[contextId] + if !ok { + return nil, fmt.Errorf("inventory for specified contextId not found") + } + return inv, nil +} + +func (i *GenericInventory) Add(appId uint32, contextId uint64, inv *Inventory) { + iMap := (map[uint32]map[uint64]*Inventory)(*i) + iMap2, ok := iMap[appId] + if !ok { + iMap2 = make(map[uint64]*Inventory) + iMap[appId] = iMap2 + } + iMap2[contextId] = inv +} + +type Inventory struct { + Items Items `json:"rgInventory"` + Currencies Currencies `json:"rgCurrency"` + Descriptions Descriptions `json:"rgDescriptions"` + AppInfo *AppInfo `json:"rgAppInfo"` +} + +// Items key is an AssetId +type Items map[string]*Item + +func (i *Items) ToMap() map[string]*Item { + return (map[string]*Item)(*i) +} + +func (i *Items) Get(assetId uint64) (*Item, error) { + iMap := (map[string]*Item)(*i) + if item, ok := iMap[strconv.FormatUint(assetId, 10)]; ok { + return item, nil + } + return nil, fmt.Errorf("item not found") +} + +func (i *Items) UnmarshalJSON(data []byte) error { + if bytes.Equal(data, []byte("[]")) { + return nil + } + return json.Unmarshal(data, (*map[string]*Item)(i)) +} + +type Currencies map[string]*Currency + +func (c *Currencies) ToMap() map[string]*Currency { + return (map[string]*Currency)(*c) +} + +func (c *Currencies) UnmarshalJSON(data []byte) error { + if bytes.Equal(data, []byte("[]")) { + return nil + } + return json.Unmarshal(data, (*map[string]*Currency)(c)) +} + +// Descriptions key format is %d_%d, first %d is ClassId, second is InstanceId +type Descriptions map[string]*Description + +func (d *Descriptions) ToMap() map[string]*Description { + return (map[string]*Description)(*d) +} + +func (d *Descriptions) Get(classId uint64, instanceId uint64) (*Description, error) { + dMap := (map[string]*Description)(*d) + descId := fmt.Sprintf("%v_%v", classId, instanceId) + if desc, ok := dMap[descId]; ok { + return desc, nil + } + return nil, fmt.Errorf("description not found") +} + +func (d *Descriptions) UnmarshalJSON(data []byte) error { + if bytes.Equal(data, []byte("[]")) { + return nil + } + return json.Unmarshal(data, (*map[string]*Description)(d)) +} + +type Item struct { + Id uint64 `json:",string"` + ClassId uint64 `json:",string"` + InstanceId uint64 `json:",string"` + Amount uint64 `json:",string"` + Pos uint32 +} + +type Currency struct { + Id uint64 `json:",string"` + ClassId uint64 `json:",string"` + IsCurrency bool `json:"is_currency"` + Pos uint32 +} + +type Description struct { + AppId uint32 `json:",string"` + ClassId uint64 `json:",string"` + InstanceId uint64 `json:",string"` + + IconUrl string `json:"icon_url"` + IconUrlLarge string `json:"icon_url_large"` + IconDragUrl string `json:"icon_drag_url"` + + Name string + MarketName string `json:"market_name"` + MarketHashName string `json:"market_hash_name"` + + // Colors in hex, for example `B2B2B2` + NameColor string `json:"name_color"` + BackgroundColor string `json:"background_color"` + + Type string + + Tradable jsont.UintBool + Marketable jsont.UintBool + Commodity jsont.UintBool + MarketTradableRestriction uint32 `json:"market_tradable_restriction,string"` + + Descriptions DescriptionLines + Actions []*Action + // Application-specific data, like "def_index" and "quality" for TF2 + AppData map[string]string + Tags []*Tag +} + +type DescriptionLines []*DescriptionLine + +func (d *DescriptionLines) UnmarshalJSON(data []byte) error { + if bytes.Equal(data, []byte(`""`)) { + return nil + } + return json.Unmarshal(data, (*[]*DescriptionLine)(d)) +} + +type DescriptionLine struct { + Value string + Type *string // Is `html` for HTML descriptions + Color *string +} + +type Action struct { + Name string + Link string +} + +type AppInfo struct { + AppId uint32 + Name string + Icon string + Link string +} + +type Tag struct { + InternalName string `json:internal_name` + Name string + Category string + CategoryName string `json:category_name` +} diff --git a/vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory_apps.go b/vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory_apps.go new file mode 100644 index 00000000..b652d551 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/economy/inventory/inventory_apps.go @@ -0,0 +1,79 @@ +package inventory + +import ( + "encoding/json" + "fmt" + "github.com/Philipp15b/go-steam/steamid" + "io/ioutil" + "net/http" + "regexp" + "strconv" +) + +type InventoryApps map[string]*InventoryApp + +func (i *InventoryApps) Get(appId uint32) (*InventoryApp, error) { + iMap := (map[string]*InventoryApp)(*i) + if inventoryApp, ok := iMap[strconv.FormatUint(uint64(appId), 10)]; ok { + return inventoryApp, nil + } + return nil, fmt.Errorf("inventory app not found") +} + +func (i *InventoryApps) ToMap() map[string]*InventoryApp { + return (map[string]*InventoryApp)(*i) +} + +type InventoryApp struct { + AppId uint32 + Name string + Icon string + Link string + AssetCount uint32 `json:"asset_count"` + InventoryLogo string `json:"inventory_logo"` + TradePermissions string `json:"trade_permissions"` + Contexts Contexts `json:"rgContexts"` +} + +type Contexts map[string]*Context + +func (c *Contexts) Get(contextId uint64) (*Context, error) { + cMap := (map[string]*Context)(*c) + if context, ok := cMap[strconv.FormatUint(contextId, 10)]; ok { + return context, nil + } + return nil, fmt.Errorf("context not found") +} + +func (c *Contexts) ToMap() map[string]*Context { + return (map[string]*Context)(*c) +} + +type Context struct { + ContextId uint64 `json:"id,string"` + AssetCount uint32 `json:"asset_count"` + Name string +} + +func GetInventoryApps(client *http.Client, steamId steamid.SteamId) (InventoryApps, error) { + resp, err := http.Get("http://steamcommunity.com/profiles/" + steamId.ToString() + "/inventory/") + if err != nil { + return nil, err + } + defer resp.Body.Close() + respBody, err := ioutil.ReadAll(resp.Body) + if err != nil { + return nil, err + } + reg := regexp.MustCompile("var g_rgAppContextData = (.*?);") + inventoryAppsMatches := reg.FindSubmatch(respBody) + if inventoryAppsMatches == nil { + return nil, fmt.Errorf("profile inventory not found in steam response") + } + var inventoryApps InventoryApps + if err = json.Unmarshal(inventoryAppsMatches[1], &inventoryApps); err != nil { + return nil, err + } + + return inventoryApps, nil +} diff --git a/vendor/github.com/Philipp15b/go-steam/economy/inventory/own.go b/vendor/github.com/Philipp15b/go-steam/economy/inventory/own.go new file mode 100644 index 00000000..140b68ac --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/economy/inventory/own.go @@ -0,0 +1,28 @@ +package inventory + +import ( + "fmt" + "net/http" + "strconv" +) + +func GetPartialOwnInventory(client *http.Client, contextId uint64, appId uint32, start *uint) (*PartialInventory, error) { + // TODO: the "trading" parameter can be left off to return non-tradable items too + url := fmt.Sprintf("http://steamcommunity.com/my/inventory/json/%d/%d?trading=1", appId, contextId) + if start != nil { + url += "&start=" + strconv.FormatUint(uint64(*start), 10) + } + req, err := http.NewRequest("GET", url, nil) + if err != nil { + panic(err) + } + return DoInventoryRequest(client, req) +} + +func GetOwnInventory(client *http.Client, contextId uint64, appId uint32) (*Inventory, error) { + return GetFullInventory(func() (*PartialInventory, error) { + return GetPartialOwnInventory(client, contextId, appId, nil) + }, func(start uint) (*PartialInventory, error) { + return GetPartialOwnInventory(client, contextId, appId, &start) + }) +} diff --git a/vendor/github.com/Philipp15b/go-steam/economy/inventory/partial.go b/vendor/github.com/Philipp15b/go-steam/economy/inventory/partial.go new file mode 100644 index 00000000..bcaad174 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/economy/inventory/partial.go @@ -0,0 +1,91 @@ +package inventory + +import ( + "bytes" + "encoding/json" + "errors" + "net/http" +) + +// A partial inventory as sent by the Steam API. +type PartialInventory struct { + Success bool + Error string + Inventory + More bool + MoreStart MoreStart `json:"more_start"` +} + +type MoreStart uint + +func (m *MoreStart) UnmarshalJSON(data []byte) error { + if bytes.Equal(data, []byte("false")) { + return nil + } + return json.Unmarshal(data, (*uint)(m)) +} + +func DoInventoryRequest(client *http.Client, req *http.Request) (*PartialInventory, error) { + resp, err := client.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + inv := new(PartialInventory) + err = json.NewDecoder(resp.Body).Decode(inv) + if err != nil { + return nil, err + } + return inv, nil +} + +func GetFullInventory(getFirst func() (*PartialInventory, error), getNext func(start uint) (*PartialInventory, error)) (*Inventory, error) { + first, err := getFirst() + if err != nil { + return nil, err + } + if !first.Success { + return nil, errors.New("GetFullInventory API call failed: " + first.Error) + } + + result := &first.Inventory + var next *PartialInventory + for latest := first; latest.More; latest = next { + next, err := getNext(uint(latest.MoreStart)) + if err != nil { + return nil, err + } + if !next.Success { + return nil, errors.New("GetFullInventory API call failed: " + next.Error) + } + + result = Merge(result, &next.Inventory) + } + + return result, nil +} + +// Merges the given Inventory into a single Inventory. +// The given slice must have at least one element. The first element of the slice is used +// and modified. +func Merge(p ...*Inventory) *Inventory { + inv := p[0] + for idx, i := range p { + if idx == 0 { + continue + } + + for key, value := range i.Items { + inv.Items[key] = value + } + for key, value := range i.Descriptions { + inv.Descriptions[key] = value + } + for key, value := range i.Currencies { + inv.Currencies[key] = value + } + } + + return inv +} diff --git a/vendor/github.com/Philipp15b/go-steam/gamecoordinator.go b/vendor/github.com/Philipp15b/go-steam/gamecoordinator.go new file mode 100644 index 00000000..9e06dad2 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/gamecoordinator.go @@ -0,0 +1,79 @@ +package steam + +import ( + "bytes" + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/gamecoordinator" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + "github.com/golang/protobuf/proto" +) + +type GameCoordinator struct { + client *Client + handlers []GCPacketHandler +} + +func newGC(client *Client) *GameCoordinator { + return &GameCoordinator{ + client: client, + handlers: make([]GCPacketHandler, 0), + } +} + +type GCPacketHandler interface { + HandleGCPacket(*GCPacket) +} + +func (g *GameCoordinator) RegisterPacketHandler(handler GCPacketHandler) { + g.handlers = append(g.handlers, handler) +} + +func (g *GameCoordinator) HandlePacket(packet *Packet) { + if packet.EMsg != EMsg_ClientFromGC { + return + } + + msg := new(CMsgGCClient) + packet.ReadProtoMsg(msg) + + p, err := NewGCPacket(msg) + if err != nil { + g.client.Errorf("Error reading GC message: %v", err) + return + } + + for _, handler := range g.handlers { + handler.HandleGCPacket(p) + } +} + +func (g *GameCoordinator) Write(msg IGCMsg) { + buf := new(bytes.Buffer) + msg.Serialize(buf) + + msgType := msg.GetMsgType() + if msg.IsProto() { + msgType = msgType | 0x80000000 // mask with protoMask + } + + g.client.Write(NewClientMsgProtobuf(EMsg_ClientToGC, &CMsgGCClient{ + Msgtype: proto.Uint32(msgType), + Appid: proto.Uint32(msg.GetAppId()), + Payload: buf.Bytes(), + })) +} + +// Sets you in the given games. Specify none to quit all games. +func (g *GameCoordinator) SetGamesPlayed(appIds ...uint64) { + games := make([]*CMsgClientGamesPlayed_GamePlayed, 0) + for _, appId := range appIds { + games = append(games, &CMsgClientGamesPlayed_GamePlayed{ + GameId: proto.Uint64(appId), + }) + } + + g.client.Write(NewClientMsgProtobuf(EMsg_ClientGamesPlayed, &CMsgClientGamesPlayed{ + GamesPlayed: games, + })) +} diff --git a/vendor/github.com/Philipp15b/go-steam/generator/generator.go b/vendor/github.com/Philipp15b/go-steam/generator/generator.go new file mode 100644 index 00000000..40522de7 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/generator/generator.go @@ -0,0 +1,295 @@ +/* +This program generates the protobuf and SteamLanguage files from the SteamKit data. +*/ +package main + +import ( + "bytes" + "fmt" + "go/ast" + "go/parser" + "go/token" + "io" + "io/ioutil" + "os" + "os/exec" + "path/filepath" + "regexp" + "runtime" + "strings" +) + +var printCommands = false + +func main() { + args := strings.Join(os.Args[1:], " ") + + found := false + if strings.Contains(args, "clean") { + clean() + found = true + } + if strings.Contains(args, "steamlang") { + buildSteamLanguage() + found = true + } + if strings.Contains(args, "proto") { + buildProto() + found = true + } + + if !found { + os.Stderr.WriteString("Invalid target!\nAvailable targets: clean, proto, steamlang\n") + os.Exit(1) + } +} + +func clean() { + print("# Cleaning") + cleanGlob("../protocol/**/*.pb.go") + cleanGlob("../tf2/protocol/**/*.pb.go") + cleanGlob("../dota/protocol/**/*.pb.go") + + os.Remove("../protocol/steamlang/enums.go") + os.Remove("../protocol/steamlang/messages.go") +} + +func cleanGlob(pattern string) { + protos, _ := filepath.Glob(pattern) + for _, proto := range protos { + err := os.Remove(proto) + if err != nil { + panic(err) + } + } +} + +func buildSteamLanguage() { + print("# Building Steam Language") + exePath := "./GoSteamLanguageGenerator/bin/Debug/GoSteamLanguageGenerator.exe" + + if runtime.GOOS != "windows" { + execute("mono", exePath, "./SteamKit", "../protocol/steamlang") + } else { + execute(exePath, "./SteamKit", "../protocol/steamlang") + } + execute("gofmt", "-w", "../protocol/steamlang/enums.go", "../protocol/steamlang/messages.go") +} + +func buildProto() { + print("# Building Protobufs") + + buildProtoMap("steamclient", clientProtoFiles, "../protocol/protobuf") + buildProtoMap("tf", tf2ProtoFiles, "../tf2/protocol/protobuf") + buildProtoMap("dota", dotaProtoFiles, "../dota/protocol/protobuf") +} + +func buildProtoMap(srcSubdir string, files map[string]string, outDir string) { + os.MkdirAll(outDir, os.ModePerm) + for proto, out := range files { + full := filepath.Join(outDir, out) + compileProto("SteamKit/Resources/Protobufs", srcSubdir, proto, full) + fixProto(full) + } +} + +// Maps the proto files to their target files. +// See `SteamKit/Resources/Protobufs/steamclient/generate-base.bat` for reference. +var clientProtoFiles = map[string]string{ + "steammessages_base.proto": "base.pb.go", + "encrypted_app_ticket.proto": "app_ticket.pb.go", + + "steammessages_clientserver.proto": "client_server.pb.go", + "steammessages_clientserver_2.proto": "client_server_2.pb.go", + + "content_manifest.proto": "content_manifest.pb.go", + + "steammessages_unified_base.steamclient.proto": "unified/base.pb.go", + "steammessages_cloud.steamclient.proto": "unified/cloud.pb.go", + "steammessages_credentials.steamclient.proto": "unified/credentials.pb.go", + "steammessages_deviceauth.steamclient.proto": "unified/deviceauth.pb.go", + "steammessages_gamenotifications.steamclient.proto": "unified/gamenotifications.pb.go", + "steammessages_offline.steamclient.proto": "unified/offline.pb.go", + "steammessages_parental.steamclient.proto": "unified/parental.pb.go", + "steammessages_partnerapps.steamclient.proto": "unified/partnerapps.pb.go", + "steammessages_player.steamclient.proto": "unified/player.pb.go", + "steammessages_publishedfile.steamclient.proto": "unified/publishedfile.pb.go", +} + +var tf2ProtoFiles = map[string]string{ + "base_gcmessages.proto": "base.pb.go", + "econ_gcmessages.proto": "econ.pb.go", + "gcsdk_gcmessages.proto": "gcsdk.pb.go", + "tf_gcmessages.proto": "tf.pb.go", + "gcsystemmsgs.proto": "system.pb.go", +} + +var dotaProtoFiles = map[string]string{ + "base_gcmessages.proto": "base.pb.go", + "econ_gcmessages.proto": "econ.pb.go", + "gcsdk_gcmessages.proto": "gcsdk.pb.go", + "dota_gcmessages_common.proto": "dota_common.pb.go", + "dota_gcmessages_client.proto": "dota_client.pb.go", + "dota_gcmessages_client_fantasy.proto": "dota_client_fantasy.pb.go", + "gcsystemmsgs.proto": "system.pb.go", +} + +func compileProto(srcBase, srcSubdir, proto, target string) { + outDir, _ := filepath.Split(target) + err := os.MkdirAll(outDir, os.ModePerm) + if err != nil { + panic(err) + } + execute("protoc", "--go_out="+outDir, "-I="+srcBase+"/"+srcSubdir, "-I="+srcBase, filepath.Join(srcBase, srcSubdir, proto)) + out := strings.Replace(filepath.Join(outDir, proto), ".proto", ".pb.go", 1) + err = forceRename(out, target) + if err != nil { + panic(err) + } +} + +func forceRename(from, to string) error { + if from != to { + os.Remove(to) + } + return os.Rename(from, to) +} + +var pkgRegex = regexp.MustCompile(`(package \w+)`) +var pkgCommentRegex = regexp.MustCompile(`(?s)(\/\*.*?\*\/\n)package`) +var unusedImportCommentRegex = regexp.MustCompile("// discarding unused import .*\n") +var fileDescriptorVarRegex = regexp.MustCompile(`fileDescriptor\d+`) + +func fixProto(path string) { + // goprotobuf is really bad at dependencies, so we must fix them manually... + // It tries to load each dependency of a file as a seperate package (but in a very, very wrong way). + // Because we want some files in the same package, we'll remove those imports to local files. + + file, err := ioutil.ReadFile(path) + if err != nil { + panic(err) + } + + fset := token.NewFileSet() + f, err := parser.ParseFile(fset, path, file, parser.ImportsOnly) + if err != nil { + panic("Error parsing " + path + ": " + err.Error()) + } + + importsToRemove := make([]*ast.ImportSpec, 0) + for _, i := range f.Imports { + // We remove all local imports + if i.Path.Value == "\".\"" { + importsToRemove = append(importsToRemove, i) + } + } + + for _, itr := range importsToRemove { + // remove the package name from all types + file = bytes.Replace(file, []byte(itr.Name.Name+"."), []byte{}, -1) + // and remove the import itself + file = bytes.Replace(file, []byte(fmt.Sprintf("import %v %v\n", itr.Name.Name, itr.Path.Value)), []byte{}, -1) + } + + // remove the package comment because it just includes a list of all messages and + // collides not only with the other compiled protobuf files, but also our own documentation. + file = cutAllSubmatch(pkgCommentRegex, file, 1) + + // remove warnings + file = unusedImportCommentRegex.ReplaceAllLiteral(file, []byte{}) + + // fix the package name + file = pkgRegex.ReplaceAll(file, []byte("package "+inferPackageName(path))) + + // fix the google dependency; + // we just reuse the one from protoc-gen-go + file = bytes.Replace(file, []byte("google/protobuf"), []byte("github.com/golang/protobuf/protoc-gen-go/descriptor"), -1) + + // we need to prefix local variables created by protoc-gen-go so that they don't clash with others in the same package + filename := strings.Split(filepath.Base(path), ".")[0] + file = fileDescriptorVarRegex.ReplaceAllFunc(file, func(match []byte) []byte { + return []byte(filename + "_" + string(match)) + }) + + err = ioutil.WriteFile(path, file, os.ModePerm) + if err != nil { + panic(err) + } +} + +func inferPackageName(path string) string { + pieces := strings.Split(path, string(filepath.Separator)) + return pieces[len(pieces)-2] +} + +func cutAllSubmatch(r *regexp.Regexp, b []byte, n int) []byte { + i := r.FindSubmatchIndex(b) + return bytesCut(b, i[2*n], i[2*n+1]) +} + +// Removes the given section from the byte array +func bytesCut(b []byte, from, to int) []byte { + buf := new(bytes.Buffer) + buf.Write(b[:from]) + buf.Write(b[to:]) + return buf.Bytes() +} + +func print(text string) { os.Stdout.WriteString(text + "\n") } + +func printerr(text string) { os.Stderr.WriteString(text + "\n") } + +// This writer appends a "> " after every newline so that the outpout appears quoted. +type QuotedWriter struct { + w io.Writer + started bool +} + +func NewQuotedWriter(w io.Writer) *QuotedWriter { + return &QuotedWriter{w, false} +} + +func (w *QuotedWriter) Write(p []byte) (n int, err error) { + if !w.started { + _, err = w.w.Write([]byte("> ")) + if err != nil { + return n, err + } + w.started = true + } + + for i, c := range p { + if c == '\n' { + nw, err := w.w.Write(p[n : i+1]) + n += nw + if err != nil { + return n, err + } + + _, err = w.w.Write([]byte("> ")) + if err != nil { + return n, err + } + } + } + if n != len(p) { + nw, err := w.w.Write(p[n:len(p)]) + n += nw + return n, err + } + return +} + +func execute(command string, args ...string) { + if printCommands { + print(command + " " + strings.Join(args, " ")) + } + cmd := exec.Command(command, args...) + cmd.Stdout = NewQuotedWriter(os.Stdout) + cmd.Stderr = NewQuotedWriter(os.Stderr) + err := cmd.Run() + if err != nil { + printerr(err.Error()) + os.Exit(1) + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/gsbot/gsbot.go b/vendor/github.com/Philipp15b/go-steam/gsbot/gsbot.go new file mode 100644 index 00000000..ddcd1af6 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/gsbot/gsbot.go @@ -0,0 +1,210 @@ +// The GsBot package contains some useful utilites for working with the +// steam package. It implements authentication with sentries, server lists and +// logging messages and events. +// +// Every module is optional and requires an instance of the GsBot struct. +// Should a module have a `HandlePacket` method, you must register it with the +// steam.Client with `RegisterPacketHandler`. Any module with a `HandleEvent` +// method must be integrated into your event loop and should be called for each +// event you receive. +package gsbot + +import ( + "encoding/hex" + "encoding/json" + "fmt" + "io/ioutil" + "log" + "math/rand" + "net" + "os" + "path" + "reflect" + "time" + + "github.com/Philipp15b/go-steam" + "github.com/Philipp15b/go-steam/netutil" + "github.com/Philipp15b/go-steam/protocol" + "github.com/davecgh/go-spew/spew" +) + +// Base structure holding common data among GsBot modules. +type GsBot struct { + Client *steam.Client + Log *log.Logger +} + +// Creates a new GsBot with a new steam.Client where logs are written to stdout. +func Default() *GsBot { + return &GsBot{ + steam.NewClient(), + log.New(os.Stdout, "", 0), + } +} + +// This module handles authentication. It logs on automatically after a ConnectedEvent +// and saves the sentry data to a file which is also used for logon if available. +// If you're logging on for the first time Steam may require an authcode. You can then +// connect again with the new logon details. +type Auth struct { + bot *GsBot + details *LogOnDetails + sentryPath string + machineAuthHash []byte +} + +func NewAuth(bot *GsBot, details *LogOnDetails, sentryPath string) *Auth { + return &Auth{ + bot: bot, + details: details, + sentryPath: sentryPath, + } +} + +type LogOnDetails struct { + Username string + Password string + AuthCode string + TwoFactorCode string +} + +// This is called automatically after every ConnectedEvent, but must be called once again manually +// with an authcode if Steam requires it when logging on for the first time. +func (a *Auth) LogOn(details *LogOnDetails) { + a.details = details + sentry, err := ioutil.ReadFile(a.sentryPath) + if err != nil { + a.bot.Log.Printf("Error loading sentry file from path %v - This is normal if you're logging in for the first time.\n", a.sentryPath) + } + a.bot.Client.Auth.LogOn(&steam.LogOnDetails{ + Username: details.Username, + Password: details.Password, + SentryFileHash: sentry, + AuthCode: details.AuthCode, + TwoFactorCode: details.TwoFactorCode, + }) +} + +func (a *Auth) HandleEvent(event interface{}) { + switch e := event.(type) { + case *steam.ConnectedEvent: + a.LogOn(a.details) + case *steam.LoggedOnEvent: + a.bot.Log.Printf("Logged on (%v) with SteamId %v and account flags %v", e.Result, e.ClientSteamId, e.AccountFlags) + case *steam.MachineAuthUpdateEvent: + a.machineAuthHash = e.Hash + err := ioutil.WriteFile(a.sentryPath, e.Hash, 0666) + if err != nil { + panic(err) + } + } +} + +// This module saves the server list from ClientCMListEvent and uses +// it when you call `Connect()`. +type ServerList struct { + bot *GsBot + listPath string +} + +func NewServerList(bot *GsBot, listPath string) *ServerList { + return &ServerList{ + bot, + listPath, + } +} + +func (s *ServerList) HandleEvent(event interface{}) { + switch e := event.(type) { + case *steam.ClientCMListEvent: + d, err := json.Marshal(e.Addresses) + if err != nil { + panic(err) + } + err = ioutil.WriteFile(s.listPath, d, 0666) + if err != nil { + panic(err) + } + } +} + +func (s *ServerList) Connect() (bool, error) { + return s.ConnectBind(nil) +} + +func (s *ServerList) ConnectBind(laddr *net.TCPAddr) (bool, error) { + d, err := ioutil.ReadFile(s.listPath) + if err != nil { + s.bot.Log.Println("Connecting to random server.") + s.bot.Client.Connect() + return false, nil + } + var addrs []*netutil.PortAddr + err = json.Unmarshal(d, &addrs) + if err != nil { + return false, err + } + raddr := addrs[rand.Intn(len(addrs))] + s.bot.Log.Printf("Connecting to %v from server list\n", raddr) + s.bot.Client.ConnectToBind(raddr, laddr) + return true, nil +} + +// This module logs incoming packets and events to a directory. +type Debug struct { + packetId, eventId uint64 + bot *GsBot + base string +} + +func NewDebug(bot *GsBot, base string) (*Debug, error) { + base = path.Join(base, fmt.Sprint(time.Now().Unix())) + err := os.MkdirAll(path.Join(base, "events"), 0700) + if err != nil { + return nil, err + } + err = os.MkdirAll(path.Join(base, "packets"), 0700) + if err != nil { + return nil, err + } + return &Debug{ + 0, 0, + bot, + base, + }, nil +} + +func (d *Debug) HandlePacket(packet *protocol.Packet) { + d.packetId++ + name := path.Join(d.base, "packets", fmt.Sprintf("%d_%d_%s", time.Now().Unix(), d.packetId, packet.EMsg)) + + text := packet.String() + "\n\n" + hex.Dump(packet.Data) + err := ioutil.WriteFile(name+".txt", []byte(text), 0666) + if err != nil { + panic(err) + } + + err = ioutil.WriteFile(name+".bin", packet.Data, 0666) + if err != nil { + panic(err) + } +} + +func (d *Debug) HandleEvent(event interface{}) { + d.eventId++ + name := fmt.Sprintf("%d_%d_%s.txt", time.Now().Unix(), d.eventId, name(event)) + err := ioutil.WriteFile(path.Join(d.base, "events", name), []byte(spew.Sdump(event)), 0666) + if err != nil { + panic(err) + } +} + +func name(obj interface{}) string { + val := reflect.ValueOf(obj) + ind := reflect.Indirect(val) + if ind.IsValid() { + return ind.Type().Name() + } else { + return val.Type().Name() + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/gsbot/gsbot/gsbot.go b/vendor/github.com/Philipp15b/go-steam/gsbot/gsbot/gsbot.go new file mode 100644 index 00000000..069dca50 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/gsbot/gsbot/gsbot.go @@ -0,0 +1,56 @@ +// A simple example that uses the modules from the gsbot package and go-steam to log on +// to the Steam network. +// +// The command expects log on data, optionally with an auth code: +// +// gsbot [username] [password] +// gsbot [username] [password] [authcode] +package main + +import ( + "fmt" + "os" + + "github.com/Philipp15b/go-steam" + "github.com/Philipp15b/go-steam/gsbot" + "github.com/Philipp15b/go-steam/protocol/steamlang" +) + +func main() { + if len(os.Args) < 3 { + fmt.Println("gsbot example\nusage: \n\tgsbot [username] [password] [authcode]") + return + } + authcode := "" + if len(os.Args) > 3 { + authcode = os.Args[3] + } + + bot := gsbot.Default() + client := bot.Client + auth := gsbot.NewAuth(bot, &gsbot.LogOnDetails{ + os.Args[1], + os.Args[2], + authcode, + }, "sentry.bin") + debug, err := gsbot.NewDebug(bot, "debug") + if err != nil { + panic(err) + } + client.RegisterPacketHandler(debug) + serverList := gsbot.NewServerList(bot, "serverlist.json") + serverList.Connect() + + for event := range client.Events() { + auth.HandleEvent(event) + debug.HandleEvent(event) + serverList.HandleEvent(event) + + switch e := event.(type) { + case error: + fmt.Printf("Error: %v", e) + case *steam.LoggedOnEvent: + client.Social.SetPersonaState(steamlang.EPersonaState_Online) + } + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/jsont/jsont.go b/vendor/github.com/Philipp15b/go-steam/jsont/jsont.go new file mode 100644 index 00000000..0927f983 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/jsont/jsont.go @@ -0,0 +1,19 @@ +// Includes helper types for working with JSON data +package jsont + +import ( + "encoding/json" +) + +// A boolean value that can be unmarshaled from a number in JSON. +type UintBool bool + +func (u *UintBool) UnmarshalJSON(data []byte) error { + var n uint + err := json.Unmarshal(data, &n) + if err != nil { + return err + } + *u = n != 0 + return nil +} diff --git a/vendor/github.com/Philipp15b/go-steam/keys.go b/vendor/github.com/Philipp15b/go-steam/keys.go new file mode 100644 index 00000000..e736c0ca --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/keys.go @@ -0,0 +1,58 @@ +package steam + +import ( + "crypto/rsa" + "github.com/Philipp15b/go-steam/cryptoutil" + . "github.com/Philipp15b/go-steam/protocol/steamlang" +) + +var publicKeys = map[EUniverse][]byte{ + EUniverse_Public: []byte{ + 0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xDF, 0xEC, 0x1A, + 0xD6, 0x2C, 0x10, 0x66, 0x2C, 0x17, 0x35, 0x3A, 0x14, 0xB0, 0x7C, 0x59, 0x11, 0x7F, 0x9D, 0xD3, + 0xD8, 0x2B, 0x7A, 0xE3, 0xE0, 0x15, 0xCD, 0x19, 0x1E, 0x46, 0xE8, 0x7B, 0x87, 0x74, 0xA2, 0x18, + 0x46, 0x31, 0xA9, 0x03, 0x14, 0x79, 0x82, 0x8E, 0xE9, 0x45, 0xA2, 0x49, 0x12, 0xA9, 0x23, 0x68, + 0x73, 0x89, 0xCF, 0x69, 0xA1, 0xB1, 0x61, 0x46, 0xBD, 0xC1, 0xBE, 0xBF, 0xD6, 0x01, 0x1B, 0xD8, + 0x81, 0xD4, 0xDC, 0x90, 0xFB, 0xFE, 0x4F, 0x52, 0x73, 0x66, 0xCB, 0x95, 0x70, 0xD7, 0xC5, 0x8E, + 0xBA, 0x1C, 0x7A, 0x33, 0x75, 0xA1, 0x62, 0x34, 0x46, 0xBB, 0x60, 0xB7, 0x80, 0x68, 0xFA, 0x13, + 0xA7, 0x7A, 0x8A, 0x37, 0x4B, 0x9E, 0xC6, 0xF4, 0x5D, 0x5F, 0x3A, 0x99, 0xF9, 0x9E, 0xC4, 0x3A, + 0xE9, 0x63, 0xA2, 0xBB, 0x88, 0x19, 0x28, 0xE0, 0xE7, 0x14, 0xC0, 0x42, 0x89, 0x02, 0x01, 0x11, + }, + + EUniverse_Beta: []byte{ + 0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xAE, 0xD1, 0x4B, + 0xC0, 0xA3, 0x36, 0x8B, 0xA0, 0x39, 0x0B, 0x43, 0xDC, 0xED, 0x6A, 0xC8, 0xF2, 0xA3, 0xE4, 0x7E, + 0x09, 0x8C, 0x55, 0x2E, 0xE7, 0xE9, 0x3C, 0xBB, 0xE5, 0x5E, 0x0F, 0x18, 0x74, 0x54, 0x8F, 0xF3, + 0xBD, 0x56, 0x69, 0x5B, 0x13, 0x09, 0xAF, 0xC8, 0xBE, 0xB3, 0xA1, 0x48, 0x69, 0xE9, 0x83, 0x49, + 0x65, 0x8D, 0xD2, 0x93, 0x21, 0x2F, 0xB9, 0x1E, 0xFA, 0x74, 0x3B, 0x55, 0x22, 0x79, 0xBF, 0x85, + 0x18, 0xCB, 0x6D, 0x52, 0x44, 0x4E, 0x05, 0x92, 0x89, 0x6A, 0xA8, 0x99, 0xED, 0x44, 0xAE, 0xE2, + 0x66, 0x46, 0x42, 0x0C, 0xFB, 0x6E, 0x4C, 0x30, 0xC6, 0x6C, 0x5C, 0x16, 0xFF, 0xBA, 0x9C, 0xB9, + 0x78, 0x3F, 0x17, 0x4B, 0xCB, 0xC9, 0x01, 0x5D, 0x3E, 0x37, 0x70, 0xEC, 0x67, 0x5A, 0x33, 0x48, + }, + + EUniverse_Internal: []byte{ + 0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, + 0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xA8, 0xFE, 0x01, + 0x3B, 0xB6, 0xD7, 0x21, 0x4B, 0x53, 0x23, 0x6F, 0xA1, 0xAB, 0x4E, 0xF1, 0x07, 0x30, 0xA7, 0xC6, + 0x7E, 0x6A, 0x2C, 0xC2, 0x5D, 0x3A, 0xB8, 0x40, 0xCA, 0x59, 0x4D, 0x16, 0x2D, 0x74, 0xEB, 0x0E, + 0x72, 0x46, 0x29, 0xF9, 0xDE, 0x9B, 0xCE, 0x4B, 0x8C, 0xD0, 0xCA, 0xF4, 0x08, 0x94, 0x46, 0xA5, + 0x11, 0xAF, 0x3A, 0xCB, 0xB8, 0x4E, 0xDE, 0xC6, 0xD8, 0x85, 0x0A, 0x7D, 0xAA, 0x96, 0x0A, 0xEA, + 0x7B, 0x51, 0xD6, 0x22, 0x62, 0x5C, 0x1E, 0x58, 0xD7, 0x46, 0x1E, 0x09, 0xAE, 0x43, 0xA7, 0xC4, + 0x34, 0x69, 0xA2, 0xA5, 0xE8, 0x44, 0x76, 0x18, 0xE2, 0x3D, 0xB7, 0xC5, 0xA8, 0x96, 0xFD, 0xE5, + 0xB4, 0x4B, 0xF8, 0x40, 0x12, 0xA6, 0x17, 0x4E, 0xC4, 0xC1, 0x60, 0x0E, 0xB0, 0xC2, 0xB8, 0x40, + }, +} + +func GetPublicKey(universe EUniverse) *rsa.PublicKey { + bytes, ok := publicKeys[universe] + if !ok { + return nil + } + key, err := cryptoutil.ParseASN1RSAPublicKey(bytes) + if err != nil { + panic(err) + } + return key +} diff --git a/vendor/github.com/Philipp15b/go-steam/netutil/addr.go b/vendor/github.com/Philipp15b/go-steam/netutil/addr.go new file mode 100644 index 00000000..72b959e6 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/netutil/addr.go @@ -0,0 +1,43 @@ +package netutil + +import ( + "net" + "strconv" + "strings" +) + +// An addr that is neither restricted to TCP nor UDP, but has an IP and a port. +type PortAddr struct { + IP net.IP + Port uint16 +} + +// Parses an IP address with a port, for example "209.197.29.196:27017". +// If the given string is not valid, this function returns nil. +func ParsePortAddr(addr string) *PortAddr { + parts := strings.Split(addr, ":") + if len(parts) != 2 { + return nil + } + ip := net.ParseIP(parts[0]) + if ip == nil { + return nil + } + port, err := strconv.ParseUint(parts[1], 10, 16) + if err != nil { + return nil + } + return &PortAddr{ip, uint16(port)} +} + +func (p *PortAddr) ToTCPAddr() *net.TCPAddr { + return &net.TCPAddr{p.IP, int(p.Port), ""} +} + +func (p *PortAddr) ToUDPAddr() *net.UDPAddr { + return &net.UDPAddr{p.IP, int(p.Port), ""} +} + +func (p *PortAddr) String() string { + return p.IP.String() + ":" + strconv.FormatUint(uint64(p.Port), 10) +} diff --git a/vendor/github.com/Philipp15b/go-steam/netutil/http.go b/vendor/github.com/Philipp15b/go-steam/netutil/http.go new file mode 100644 index 00000000..fdaa055a --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/netutil/http.go @@ -0,0 +1,17 @@ +package netutil + +import ( + "net/http" + "net/url" + "strings" +) + +// Version of http.Client.PostForm that returns a new request instead of executing it directly. +func NewPostForm(url string, data url.Values) *http.Request { + req, err := http.NewRequest("POST", url, strings.NewReader(data.Encode())) + if err != nil { + panic(err) + } + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + return req +} diff --git a/vendor/github.com/Philipp15b/go-steam/netutil/url.go b/vendor/github.com/Philipp15b/go-steam/netutil/url.go new file mode 100644 index 00000000..4598ec3e --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/netutil/url.go @@ -0,0 +1,13 @@ +package netutil + +import ( + "net/url" +) + +func ToUrlValues(m map[string]string) url.Values { + r := make(url.Values) + for k, v := range m { + r.Add(k, v) + } + return r +} diff --git a/vendor/github.com/Philipp15b/go-steam/notifications.go b/vendor/github.com/Philipp15b/go-steam/notifications.go new file mode 100644 index 00000000..09969055 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/notifications.go @@ -0,0 +1,62 @@ +package steam + +import ( + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" +) + +type Notifications struct { + // Maps notification types to their count. If a type is not present in the map, + // its count is zero. + notifications map[NotificationType]uint + client *Client +} + +func newNotifications(client *Client) *Notifications { + return &Notifications{ + make(map[NotificationType]uint), + client, + } +} + +func (n *Notifications) HandlePacket(packet *Packet) { + switch packet.EMsg { + case EMsg_ClientUserNotifications: + n.handleClientUserNotifications(packet) + } +} + +type NotificationType uint + +const ( + TradeOffer NotificationType = 1 +) + +func (n *Notifications) handleClientUserNotifications(packet *Packet) { + msg := new(CMsgClientUserNotifications) + packet.ReadProtoMsg(msg) + + for _, notification := range msg.GetNotifications() { + typ := NotificationType(*notification.UserNotificationType) + count := uint(*notification.Count) + n.notifications[typ] = count + n.client.Emit(&NotificationEvent{typ, count}) + } + + // check if there is a notification in our map that isn't in the current packet + for typ, _ := range n.notifications { + exists := false + for _, t := range msg.GetNotifications() { + if NotificationType(*t.UserNotificationType) == typ { + exists = true + break + } + } + + if !exists { + delete(n.notifications, typ) + n.client.Emit(&NotificationEvent{typ, 0}) + } + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/notifications_events.go b/vendor/github.com/Philipp15b/go-steam/notifications_events.go new file mode 100644 index 00000000..7b028a2b --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/notifications_events.go @@ -0,0 +1,9 @@ +package steam + +// This event is emitted for every CMsgClientUserNotifications message and likewise only used for +// trade offers. Unlike the the above it is also emitted when the count of a type that was tracked +// before by this Notifications instance reaches zero. +type NotificationEvent struct { + Type NotificationType + Count uint +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/doc.go b/vendor/github.com/Philipp15b/go-steam/protocol/doc.go new file mode 100644 index 00000000..5096a7d7 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/doc.go @@ -0,0 +1,18 @@ +/* +This package includes some basics for the Steam protocol. It defines basic interfaces that are used throughout go-steam: +There is IMsg, which is extended by IClientMsg (sent after logging in) and abstracts over +the outgoing message types. Both interfaces are implemented by ClientMsgProtobuf and ClientMsg. +Msg is like ClientMsg, but it is used for sending messages before logging in. + +There is also the concept of a Packet: This is a type for incoming messages where only +the header is deserialized. It therefore only contains EMsg data, job information and the remaining data. +Its contents can then be read via the Read* methods which read data into a MessageBody - a type which is Serializable and +has an EMsg. + +In addition, there are extra types for communication with the Game Coordinator (GC) included in the gamecoordinator sub-package. +For outgoing messages the IGCMsg interface is used which is implemented by GCMsgProtobuf and GCMsg. +Incoming messages are of the GCPacket type and are read like regular Packets. + +The actual messages and enums are in the sub-packages steamlang and protobuf, generated from the SteamKit data. +*/ +package protocol diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/msg.go b/vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/msg.go new file mode 100644 index 00000000..f2eeb8b3 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/msg.go @@ -0,0 +1,132 @@ +package gamecoordinator + +import ( + "io" + + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + "github.com/golang/protobuf/proto" +) + +// An outgoing message to the Game Coordinator. +type IGCMsg interface { + Serializer + IsProto() bool + GetAppId() uint32 + GetMsgType() uint32 + + GetTargetJobId() JobId + SetTargetJobId(JobId) + GetSourceJobId() JobId + SetSourceJobId(JobId) +} + +type GCMsgProtobuf struct { + AppId uint32 + Header *MsgGCHdrProtoBuf + Body proto.Message +} + +func NewGCMsgProtobuf(appId, msgType uint32, body proto.Message) *GCMsgProtobuf { + hdr := NewMsgGCHdrProtoBuf() + hdr.Msg = msgType + return &GCMsgProtobuf{ + AppId: appId, + Header: hdr, + Body: body, + } +} + +func (g *GCMsgProtobuf) IsProto() bool { + return true +} + +func (g *GCMsgProtobuf) GetAppId() uint32 { + return g.AppId +} + +func (g *GCMsgProtobuf) GetMsgType() uint32 { + return g.Header.Msg +} + +func (g *GCMsgProtobuf) GetTargetJobId() JobId { + return JobId(g.Header.Proto.GetJobidTarget()) +} + +func (g *GCMsgProtobuf) SetTargetJobId(job JobId) { + g.Header.Proto.JobidTarget = proto.Uint64(uint64(job)) +} + +func (g *GCMsgProtobuf) GetSourceJobId() JobId { + return JobId(g.Header.Proto.GetJobidSource()) +} + +func (g *GCMsgProtobuf) SetSourceJobId(job JobId) { + g.Header.Proto.JobidSource = proto.Uint64(uint64(job)) +} + +func (g *GCMsgProtobuf) Serialize(w io.Writer) error { + err := g.Header.Serialize(w) + if err != nil { + return err + } + body, err := proto.Marshal(g.Body) + if err != nil { + return err + } + _, err = w.Write(body) + return err +} + +type GCMsg struct { + AppId uint32 + MsgType uint32 + Header *MsgGCHdr + Body Serializer +} + +func NewGCMsg(appId, msgType uint32, body Serializer) *GCMsg { + return &GCMsg{ + AppId: appId, + MsgType: msgType, + Header: NewMsgGCHdr(), + Body: body, + } +} + +func (g *GCMsg) GetMsgType() uint32 { + return g.MsgType +} + +func (g *GCMsg) GetAppId() uint32 { + return g.AppId +} + +func (g *GCMsg) IsProto() bool { + return false +} + +func (g *GCMsg) GetTargetJobId() JobId { + return JobId(g.Header.TargetJobID) +} + +func (g *GCMsg) SetTargetJobId(job JobId) { + g.Header.TargetJobID = uint64(job) +} + +func (g *GCMsg) GetSourceJobId() JobId { + return JobId(g.Header.SourceJobID) +} + +func (g *GCMsg) SetSourceJobId(job JobId) { + g.Header.SourceJobID = uint64(job) +} + +func (g *GCMsg) Serialize(w io.Writer) error { + err := g.Header.Serialize(w) + if err != nil { + return err + } + err = g.Body.Serialize(w) + return err +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/packet.go b/vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/packet.go new file mode 100644 index 00000000..260e1201 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/gamecoordinator/packet.go @@ -0,0 +1,61 @@ +package gamecoordinator + +import ( + "bytes" + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + "github.com/golang/protobuf/proto" +) + +// An incoming, partially unread message from the Game Coordinator. +type GCPacket struct { + AppId uint32 + MsgType uint32 + IsProto bool + GCName string + Body []byte + TargetJobId JobId +} + +func NewGCPacket(wrapper *CMsgGCClient) (*GCPacket, error) { + packet := &GCPacket{ + AppId: wrapper.GetAppid(), + MsgType: wrapper.GetMsgtype(), + GCName: wrapper.GetGcname(), + } + + r := bytes.NewReader(wrapper.GetPayload()) + if IsProto(wrapper.GetMsgtype()) { + packet.MsgType = packet.MsgType & EMsgMask + packet.IsProto = true + + header := NewMsgGCHdrProtoBuf() + err := header.Deserialize(r) + if err != nil { + return nil, err + } + packet.TargetJobId = JobId(header.Proto.GetJobidTarget()) + } else { + header := NewMsgGCHdr() + err := header.Deserialize(r) + if err != nil { + return nil, err + } + packet.TargetJobId = JobId(header.TargetJobID) + } + + body := make([]byte, r.Len()) + r.Read(body) + packet.Body = body + + return packet, nil +} + +func (g *GCPacket) ReadProtoMsg(body proto.Message) { + proto.Unmarshal(g.Body, body) +} + +func (g *GCPacket) ReadMsg(body MessageBody) { + body.Deserialize(bytes.NewReader(g.Body)) +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/internal.go b/vendor/github.com/Philipp15b/go-steam/protocol/internal.go new file mode 100644 index 00000000..d9376384 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/internal.go @@ -0,0 +1,47 @@ +package protocol + +import ( + "io" + "math" + "strconv" + + . "github.com/Philipp15b/go-steam/protocol/steamlang" +) + +type JobId uint64 + +func (j JobId) String() string { + if j == math.MaxUint64 { + return "(none)" + } + return strconv.FormatUint(uint64(j), 10) +} + +type Serializer interface { + Serialize(w io.Writer) error +} + +type Deserializer interface { + Deserialize(r io.Reader) error +} + +type Serializable interface { + Serializer + Deserializer +} + +type MessageBody interface { + Serializable + GetEMsg() EMsg +} + +// the default details to request in most situations +const EClientPersonaStateFlag_DefaultInfoRequest = EClientPersonaStateFlag_PlayerName | + EClientPersonaStateFlag_Presence | EClientPersonaStateFlag_SourceID | + EClientPersonaStateFlag_GameExtraInfo + +const DefaultAvatar = "fef49e7fa7e1997310d705b2a6158ff8dc1cdfeb" + +func ValidAvatar(avatar string) bool { + return !(avatar == "0000000000000000000000000000000000000000" || len(avatar) != 40) +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/msg.go b/vendor/github.com/Philipp15b/go-steam/protocol/msg.go new file mode 100644 index 00000000..236e6737 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/msg.go @@ -0,0 +1,221 @@ +package protocol + +import ( + "github.com/golang/protobuf/proto" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" + "io" +) + +// Interface for all messages, typically outgoing. They can also be created by +// using the Read* methods in a PacketMsg. +type IMsg interface { + Serializer + IsProto() bool + GetMsgType() EMsg + GetTargetJobId() JobId + SetTargetJobId(JobId) + GetSourceJobId() JobId + SetSourceJobId(JobId) +} + +// Interface for client messages, i.e. messages that are sent after logging in. +// ClientMsgProtobuf and ClientMsg implement this. +type IClientMsg interface { + IMsg + GetSessionId() int32 + SetSessionId(int32) + GetSteamId() SteamId + SetSteamId(SteamId) +} + +// Represents a protobuf backed client message with session data. +type ClientMsgProtobuf struct { + Header *MsgHdrProtoBuf + Body proto.Message +} + +func NewClientMsgProtobuf(eMsg EMsg, body proto.Message) *ClientMsgProtobuf { + hdr := NewMsgHdrProtoBuf() + hdr.Msg = eMsg + return &ClientMsgProtobuf{ + Header: hdr, + Body: body, + } +} + +func (c *ClientMsgProtobuf) IsProto() bool { + return true +} + +func (c *ClientMsgProtobuf) GetMsgType() EMsg { + return NewEMsg(uint32(c.Header.Msg)) +} + +func (c *ClientMsgProtobuf) GetSessionId() int32 { + return c.Header.Proto.GetClientSessionid() +} + +func (c *ClientMsgProtobuf) SetSessionId(session int32) { + c.Header.Proto.ClientSessionid = &session +} + +func (c *ClientMsgProtobuf) GetSteamId() SteamId { + return SteamId(c.Header.Proto.GetSteamid()) +} + +func (c *ClientMsgProtobuf) SetSteamId(s SteamId) { + c.Header.Proto.Steamid = proto.Uint64(uint64(s)) +} + +func (c *ClientMsgProtobuf) GetTargetJobId() JobId { + return JobId(c.Header.Proto.GetJobidTarget()) +} + +func (c *ClientMsgProtobuf) SetTargetJobId(job JobId) { + c.Header.Proto.JobidTarget = proto.Uint64(uint64(job)) +} + +func (c *ClientMsgProtobuf) GetSourceJobId() JobId { + return JobId(c.Header.Proto.GetJobidSource()) +} + +func (c *ClientMsgProtobuf) SetSourceJobId(job JobId) { + c.Header.Proto.JobidSource = proto.Uint64(uint64(job)) +} + +func (c *ClientMsgProtobuf) Serialize(w io.Writer) error { + err := c.Header.Serialize(w) + if err != nil { + return err + } + body, err := proto.Marshal(c.Body) + if err != nil { + return err + } + _, err = w.Write(body) + return err +} + +// Represents a struct backed client message. +type ClientMsg struct { + Header *ExtendedClientMsgHdr + Body MessageBody + Payload []byte +} + +func NewClientMsg(body MessageBody, payload []byte) *ClientMsg { + hdr := NewExtendedClientMsgHdr() + hdr.Msg = body.GetEMsg() + return &ClientMsg{ + Header: hdr, + Body: body, + Payload: payload, + } +} + +func (c *ClientMsg) IsProto() bool { + return true +} + +func (c *ClientMsg) GetMsgType() EMsg { + return c.Header.Msg +} + +func (c *ClientMsg) GetSessionId() int32 { + return c.Header.SessionID +} + +func (c *ClientMsg) SetSessionId(session int32) { + c.Header.SessionID = session +} + +func (c *ClientMsg) GetSteamId() SteamId { + return c.Header.SteamID +} + +func (c *ClientMsg) SetSteamId(s SteamId) { + c.Header.SteamID = s +} + +func (c *ClientMsg) GetTargetJobId() JobId { + return JobId(c.Header.TargetJobID) +} + +func (c *ClientMsg) SetTargetJobId(job JobId) { + c.Header.TargetJobID = uint64(job) +} + +func (c *ClientMsg) GetSourceJobId() JobId { + return JobId(c.Header.SourceJobID) +} + +func (c *ClientMsg) SetSourceJobId(job JobId) { + c.Header.SourceJobID = uint64(job) +} + +func (c *ClientMsg) Serialize(w io.Writer) error { + err := c.Header.Serialize(w) + if err != nil { + return err + } + err = c.Body.Serialize(w) + if err != nil { + return err + } + _, err = w.Write(c.Payload) + return err +} + +type Msg struct { + Header *MsgHdr + Body MessageBody + Payload []byte +} + +func NewMsg(body MessageBody, payload []byte) *Msg { + hdr := NewMsgHdr() + hdr.Msg = body.GetEMsg() + return &Msg{ + Header: hdr, + Body: body, + Payload: payload, + } +} + +func (m *Msg) GetMsgType() EMsg { + return m.Header.Msg +} + +func (m *Msg) IsProto() bool { + return false +} + +func (m *Msg) GetTargetJobId() JobId { + return JobId(m.Header.TargetJobID) +} + +func (m *Msg) SetTargetJobId(job JobId) { + m.Header.TargetJobID = uint64(job) +} + +func (m *Msg) GetSourceJobId() JobId { + return JobId(m.Header.SourceJobID) +} + +func (m *Msg) SetSourceJobId(job JobId) { + m.Header.SourceJobID = uint64(job) +} + +func (m *Msg) Serialize(w io.Writer) error { + err := m.Header.Serialize(w) + if err != nil { + return err + } + err = m.Body.Serialize(w) + if err != nil { + return err + } + _, err = w.Write(m.Payload) + return err +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/packet.go b/vendor/github.com/Philipp15b/go-steam/protocol/packet.go new file mode 100644 index 00000000..d6b2e425 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/packet.go @@ -0,0 +1,116 @@ +package protocol + +import ( + "bytes" + "github.com/golang/protobuf/proto" + "encoding/binary" + "fmt" + . "github.com/Philipp15b/go-steam/protocol/steamlang" +) + +// TODO: Headers are always deserialized twice. + +// Represents an incoming, partially unread message. +type Packet struct { + EMsg EMsg + IsProto bool + TargetJobId JobId + SourceJobId JobId + Data []byte +} + +func NewPacket(data []byte) (*Packet, error) { + var rawEMsg uint32 + err := binary.Read(bytes.NewReader(data), binary.LittleEndian, &rawEMsg) + if err != nil { + return nil, err + } + eMsg := NewEMsg(rawEMsg) + buf := bytes.NewReader(data) + if eMsg == EMsg_ChannelEncryptRequest || eMsg == EMsg_ChannelEncryptResult { + header := NewMsgHdr() + header.Msg = eMsg + err = header.Deserialize(buf) + if err != nil { + return nil, err + } + return &Packet{ + EMsg: eMsg, + IsProto: false, + TargetJobId: JobId(header.TargetJobID), + SourceJobId: JobId(header.SourceJobID), + Data: data, + }, nil + } else if IsProto(rawEMsg) { + header := NewMsgHdrProtoBuf() + header.Msg = eMsg + err = header.Deserialize(buf) + if err != nil { + return nil, err + } + return &Packet{ + EMsg: eMsg, + IsProto: true, + TargetJobId: JobId(header.Proto.GetJobidTarget()), + SourceJobId: JobId(header.Proto.GetJobidSource()), + Data: data, + }, nil + } else { + header := NewExtendedClientMsgHdr() + header.Msg = eMsg + err = header.Deserialize(buf) + if err != nil { + return nil, err + } + return &Packet{ + EMsg: eMsg, + IsProto: false, + TargetJobId: JobId(header.TargetJobID), + SourceJobId: JobId(header.SourceJobID), + Data: data, + }, nil + } +} + +func (p *Packet) String() string { + return fmt.Sprintf("Packet{EMsg = %v, Proto = %v, Len = %v, TargetJobId = %v, SourceJobId = %v}", p.EMsg, p.IsProto, len(p.Data), p.TargetJobId, p.SourceJobId) +} + +func (p *Packet) ReadProtoMsg(body proto.Message) *ClientMsgProtobuf { + header := NewMsgHdrProtoBuf() + buf := bytes.NewBuffer(p.Data) + header.Deserialize(buf) + proto.Unmarshal(buf.Bytes(), body) + return &ClientMsgProtobuf{ // protobuf messages have no payload + Header: header, + Body: body, + } +} + +func (p *Packet) ReadClientMsg(body MessageBody) *ClientMsg { + header := NewExtendedClientMsgHdr() + buf := bytes.NewReader(p.Data) + header.Deserialize(buf) + body.Deserialize(buf) + payload := make([]byte, buf.Len()) + buf.Read(payload) + return &ClientMsg{ + Header: header, + Body: body, + Payload: payload, + } +} + +func (p *Packet) ReadMsg(body MessageBody) *Msg { + header := NewMsgHdr() + buf := bytes.NewReader(p.Data) + header.Deserialize(buf) + body.Deserialize(buf) + payload := make([]byte, buf.Len()) + buf.Read(payload) + return &Msg{ + Header: header, + Body: body, + Payload: payload, + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/app_ticket.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/app_ticket.pb.go new file mode 100644 index 00000000..db158e44 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/app_ticket.pb.go @@ -0,0 +1,82 @@ +// Code generated by protoc-gen-go. +// source: encrypted_app_ticket.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type EncryptedAppTicket struct { + TicketVersionNo *uint32 `protobuf:"varint,1,opt,name=ticket_version_no" json:"ticket_version_no,omitempty"` + CrcEncryptedticket *uint32 `protobuf:"varint,2,opt,name=crc_encryptedticket" json:"crc_encryptedticket,omitempty"` + CbEncrypteduserdata *uint32 `protobuf:"varint,3,opt,name=cb_encrypteduserdata" json:"cb_encrypteduserdata,omitempty"` + CbEncryptedAppownershipticket *uint32 `protobuf:"varint,4,opt,name=cb_encrypted_appownershipticket" json:"cb_encrypted_appownershipticket,omitempty"` + EncryptedTicket []byte `protobuf:"bytes,5,opt,name=encrypted_ticket" json:"encrypted_ticket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EncryptedAppTicket) Reset() { *m = EncryptedAppTicket{} } +func (m *EncryptedAppTicket) String() string { return proto.CompactTextString(m) } +func (*EncryptedAppTicket) ProtoMessage() {} +func (*EncryptedAppTicket) Descriptor() ([]byte, []int) { return app_ticket_fileDescriptor0, []int{0} } + +func (m *EncryptedAppTicket) GetTicketVersionNo() uint32 { + if m != nil && m.TicketVersionNo != nil { + return *m.TicketVersionNo + } + return 0 +} + +func (m *EncryptedAppTicket) GetCrcEncryptedticket() uint32 { + if m != nil && m.CrcEncryptedticket != nil { + return *m.CrcEncryptedticket + } + return 0 +} + +func (m *EncryptedAppTicket) GetCbEncrypteduserdata() uint32 { + if m != nil && m.CbEncrypteduserdata != nil { + return *m.CbEncrypteduserdata + } + return 0 +} + +func (m *EncryptedAppTicket) GetCbEncryptedAppownershipticket() uint32 { + if m != nil && m.CbEncryptedAppownershipticket != nil { + return *m.CbEncryptedAppownershipticket + } + return 0 +} + +func (m *EncryptedAppTicket) GetEncryptedTicket() []byte { + if m != nil { + return m.EncryptedTicket + } + return nil +} + +func init() { + proto.RegisterType((*EncryptedAppTicket)(nil), "EncryptedAppTicket") +} + +var app_ticket_fileDescriptor0 = []byte{ + // 162 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0xcd, 0x4b, 0x2e, + 0xaa, 0x2c, 0x28, 0x49, 0x4d, 0x89, 0x4f, 0x2c, 0x28, 0x88, 0x2f, 0xc9, 0x4c, 0xce, 0x4e, 0x2d, + 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x5a, 0xcb, 0xc8, 0x25, 0xe4, 0x0a, 0x93, 0x76, 0x2c, + 0x28, 0x08, 0x01, 0x4b, 0x0a, 0x49, 0x72, 0x09, 0x42, 0x94, 0xc5, 0x97, 0xa5, 0x16, 0x15, 0x67, + 0xe6, 0xe7, 0xc5, 0xe7, 0xe5, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x0a, 0x49, 0x73, 0x09, 0x27, + 0x17, 0x25, 0xc7, 0xc3, 0xcd, 0x84, 0xa8, 0x93, 0x60, 0x02, 0x4b, 0xca, 0x70, 0x89, 0x24, 0x27, + 0x21, 0xe4, 0x4a, 0x8b, 0x53, 0x8b, 0x52, 0x12, 0x4b, 0x12, 0x25, 0x98, 0xc1, 0xb2, 0xea, 0x5c, + 0xf2, 0xc8, 0xb2, 0x20, 0xd7, 0xe4, 0x97, 0xe7, 0x01, 0x2d, 0xc8, 0xc8, 0x2c, 0x80, 0x1a, 0xc3, + 0x02, 0x56, 0x28, 0xc1, 0x25, 0x80, 0x50, 0x05, 0x95, 0x61, 0x05, 0xca, 0xf0, 0x38, 0xb1, 0x7a, + 0x30, 0x36, 0x30, 0x32, 0x00, 0x02, 0x00, 0x00, 0xff, 0xff, 0x03, 0x8c, 0xdb, 0x92, 0xd3, 0x00, + 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/base.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/base.pb.go new file mode 100644 index 00000000..6a91570c --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/base.pb.go @@ -0,0 +1,613 @@ +// Code generated by protoc-gen-go. +// source: steammessages_base.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CMsgProtoBufHeader struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + ClientSessionid *int32 `protobuf:"varint,2,opt,name=client_sessionid" json:"client_sessionid,omitempty"` + RoutingAppid *uint32 `protobuf:"varint,3,opt,name=routing_appid" json:"routing_appid,omitempty"` + JobidSource *uint64 `protobuf:"fixed64,10,opt,name=jobid_source,def=18446744073709551615" json:"jobid_source,omitempty"` + JobidTarget *uint64 `protobuf:"fixed64,11,opt,name=jobid_target,def=18446744073709551615" json:"jobid_target,omitempty"` + TargetJobName *string `protobuf:"bytes,12,opt,name=target_job_name" json:"target_job_name,omitempty"` + SeqNum *int32 `protobuf:"varint,24,opt,name=seq_num" json:"seq_num,omitempty"` + Eresult *int32 `protobuf:"varint,13,opt,name=eresult,def=2" json:"eresult,omitempty"` + ErrorMessage *string `protobuf:"bytes,14,opt,name=error_message" json:"error_message,omitempty"` + Ip *uint32 `protobuf:"varint,15,opt,name=ip" json:"ip,omitempty"` + AuthAccountFlags *uint32 `protobuf:"varint,16,opt,name=auth_account_flags" json:"auth_account_flags,omitempty"` + TokenSource *uint32 `protobuf:"varint,22,opt,name=token_source" json:"token_source,omitempty"` + AdminSpoofingUser *bool `protobuf:"varint,23,opt,name=admin_spoofing_user" json:"admin_spoofing_user,omitempty"` + TransportError *int32 `protobuf:"varint,17,opt,name=transport_error,def=1" json:"transport_error,omitempty"` + Messageid *uint64 `protobuf:"varint,18,opt,name=messageid,def=18446744073709551615" json:"messageid,omitempty"` + PublisherGroupId *uint32 `protobuf:"varint,19,opt,name=publisher_group_id" json:"publisher_group_id,omitempty"` + Sysid *uint32 `protobuf:"varint,20,opt,name=sysid" json:"sysid,omitempty"` + TraceTag *uint64 `protobuf:"varint,21,opt,name=trace_tag" json:"trace_tag,omitempty"` + WebapiKeyId *uint32 `protobuf:"varint,25,opt,name=webapi_key_id" json:"webapi_key_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgProtoBufHeader) Reset() { *m = CMsgProtoBufHeader{} } +func (m *CMsgProtoBufHeader) String() string { return proto.CompactTextString(m) } +func (*CMsgProtoBufHeader) ProtoMessage() {} +func (*CMsgProtoBufHeader) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} } + +const Default_CMsgProtoBufHeader_JobidSource uint64 = 18446744073709551615 +const Default_CMsgProtoBufHeader_JobidTarget uint64 = 18446744073709551615 +const Default_CMsgProtoBufHeader_Eresult int32 = 2 +const Default_CMsgProtoBufHeader_TransportError int32 = 1 +const Default_CMsgProtoBufHeader_Messageid uint64 = 18446744073709551615 + +func (m *CMsgProtoBufHeader) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetClientSessionid() int32 { + if m != nil && m.ClientSessionid != nil { + return *m.ClientSessionid + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetRoutingAppid() uint32 { + if m != nil && m.RoutingAppid != nil { + return *m.RoutingAppid + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetJobidSource() uint64 { + if m != nil && m.JobidSource != nil { + return *m.JobidSource + } + return Default_CMsgProtoBufHeader_JobidSource +} + +func (m *CMsgProtoBufHeader) GetJobidTarget() uint64 { + if m != nil && m.JobidTarget != nil { + return *m.JobidTarget + } + return Default_CMsgProtoBufHeader_JobidTarget +} + +func (m *CMsgProtoBufHeader) GetTargetJobName() string { + if m != nil && m.TargetJobName != nil { + return *m.TargetJobName + } + return "" +} + +func (m *CMsgProtoBufHeader) GetSeqNum() int32 { + if m != nil && m.SeqNum != nil { + return *m.SeqNum + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgProtoBufHeader_Eresult +} + +func (m *CMsgProtoBufHeader) GetErrorMessage() string { + if m != nil && m.ErrorMessage != nil { + return *m.ErrorMessage + } + return "" +} + +func (m *CMsgProtoBufHeader) GetIp() uint32 { + if m != nil && m.Ip != nil { + return *m.Ip + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetAuthAccountFlags() uint32 { + if m != nil && m.AuthAccountFlags != nil { + return *m.AuthAccountFlags + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetTokenSource() uint32 { + if m != nil && m.TokenSource != nil { + return *m.TokenSource + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetAdminSpoofingUser() bool { + if m != nil && m.AdminSpoofingUser != nil { + return *m.AdminSpoofingUser + } + return false +} + +func (m *CMsgProtoBufHeader) GetTransportError() int32 { + if m != nil && m.TransportError != nil { + return *m.TransportError + } + return Default_CMsgProtoBufHeader_TransportError +} + +func (m *CMsgProtoBufHeader) GetMessageid() uint64 { + if m != nil && m.Messageid != nil { + return *m.Messageid + } + return Default_CMsgProtoBufHeader_Messageid +} + +func (m *CMsgProtoBufHeader) GetPublisherGroupId() uint32 { + if m != nil && m.PublisherGroupId != nil { + return *m.PublisherGroupId + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetSysid() uint32 { + if m != nil && m.Sysid != nil { + return *m.Sysid + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetTraceTag() uint64 { + if m != nil && m.TraceTag != nil { + return *m.TraceTag + } + return 0 +} + +func (m *CMsgProtoBufHeader) GetWebapiKeyId() uint32 { + if m != nil && m.WebapiKeyId != nil { + return *m.WebapiKeyId + } + return 0 +} + +type CMsgMulti struct { + SizeUnzipped *uint32 `protobuf:"varint,1,opt,name=size_unzipped" json:"size_unzipped,omitempty"` + MessageBody []byte `protobuf:"bytes,2,opt,name=message_body" json:"message_body,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgMulti) Reset() { *m = CMsgMulti{} } +func (m *CMsgMulti) String() string { return proto.CompactTextString(m) } +func (*CMsgMulti) ProtoMessage() {} +func (*CMsgMulti) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{1} } + +func (m *CMsgMulti) GetSizeUnzipped() uint32 { + if m != nil && m.SizeUnzipped != nil { + return *m.SizeUnzipped + } + return 0 +} + +func (m *CMsgMulti) GetMessageBody() []byte { + if m != nil { + return m.MessageBody + } + return nil +} + +type CMsgProtobufWrapped struct { + MessageBody []byte `protobuf:"bytes,1,opt,name=message_body" json:"message_body,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgProtobufWrapped) Reset() { *m = CMsgProtobufWrapped{} } +func (m *CMsgProtobufWrapped) String() string { return proto.CompactTextString(m) } +func (*CMsgProtobufWrapped) ProtoMessage() {} +func (*CMsgProtobufWrapped) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{2} } + +func (m *CMsgProtobufWrapped) GetMessageBody() []byte { + if m != nil { + return m.MessageBody + } + return nil +} + +type CMsgAuthTicket struct { + Estate *uint32 `protobuf:"varint,1,opt,name=estate" json:"estate,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + Steamid *uint64 `protobuf:"fixed64,3,opt,name=steamid" json:"steamid,omitempty"` + Gameid *uint64 `protobuf:"fixed64,4,opt,name=gameid" json:"gameid,omitempty"` + HSteamPipe *uint32 `protobuf:"varint,5,opt,name=h_steam_pipe" json:"h_steam_pipe,omitempty"` + TicketCrc *uint32 `protobuf:"varint,6,opt,name=ticket_crc" json:"ticket_crc,omitempty"` + Ticket []byte `protobuf:"bytes,7,opt,name=ticket" json:"ticket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAuthTicket) Reset() { *m = CMsgAuthTicket{} } +func (m *CMsgAuthTicket) String() string { return proto.CompactTextString(m) } +func (*CMsgAuthTicket) ProtoMessage() {} +func (*CMsgAuthTicket) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{3} } + +const Default_CMsgAuthTicket_Eresult uint32 = 2 + +func (m *CMsgAuthTicket) GetEstate() uint32 { + if m != nil && m.Estate != nil { + return *m.Estate + } + return 0 +} + +func (m *CMsgAuthTicket) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgAuthTicket_Eresult +} + +func (m *CMsgAuthTicket) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgAuthTicket) GetGameid() uint64 { + if m != nil && m.Gameid != nil { + return *m.Gameid + } + return 0 +} + +func (m *CMsgAuthTicket) GetHSteamPipe() uint32 { + if m != nil && m.HSteamPipe != nil { + return *m.HSteamPipe + } + return 0 +} + +func (m *CMsgAuthTicket) GetTicketCrc() uint32 { + if m != nil && m.TicketCrc != nil { + return *m.TicketCrc + } + return 0 +} + +func (m *CMsgAuthTicket) GetTicket() []byte { + if m != nil { + return m.Ticket + } + return nil +} + +type CCDDBAppDetailCommon struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Icon *string `protobuf:"bytes,3,opt,name=icon" json:"icon,omitempty"` + Logo *string `protobuf:"bytes,4,opt,name=logo" json:"logo,omitempty"` + LogoSmall *string `protobuf:"bytes,5,opt,name=logo_small" json:"logo_small,omitempty"` + Tool *bool `protobuf:"varint,6,opt,name=tool" json:"tool,omitempty"` + Demo *bool `protobuf:"varint,7,opt,name=demo" json:"demo,omitempty"` + Media *bool `protobuf:"varint,8,opt,name=media" json:"media,omitempty"` + CommunityVisibleStats *bool `protobuf:"varint,9,opt,name=community_visible_stats" json:"community_visible_stats,omitempty"` + FriendlyName *string `protobuf:"bytes,10,opt,name=friendly_name" json:"friendly_name,omitempty"` + Propagation *string `protobuf:"bytes,11,opt,name=propagation" json:"propagation,omitempty"` + HasAdultContent *bool `protobuf:"varint,12,opt,name=has_adult_content" json:"has_adult_content,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCDDBAppDetailCommon) Reset() { *m = CCDDBAppDetailCommon{} } +func (m *CCDDBAppDetailCommon) String() string { return proto.CompactTextString(m) } +func (*CCDDBAppDetailCommon) ProtoMessage() {} +func (*CCDDBAppDetailCommon) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{4} } + +func (m *CCDDBAppDetailCommon) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCDDBAppDetailCommon) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CCDDBAppDetailCommon) GetIcon() string { + if m != nil && m.Icon != nil { + return *m.Icon + } + return "" +} + +func (m *CCDDBAppDetailCommon) GetLogo() string { + if m != nil && m.Logo != nil { + return *m.Logo + } + return "" +} + +func (m *CCDDBAppDetailCommon) GetLogoSmall() string { + if m != nil && m.LogoSmall != nil { + return *m.LogoSmall + } + return "" +} + +func (m *CCDDBAppDetailCommon) GetTool() bool { + if m != nil && m.Tool != nil { + return *m.Tool + } + return false +} + +func (m *CCDDBAppDetailCommon) GetDemo() bool { + if m != nil && m.Demo != nil { + return *m.Demo + } + return false +} + +func (m *CCDDBAppDetailCommon) GetMedia() bool { + if m != nil && m.Media != nil { + return *m.Media + } + return false +} + +func (m *CCDDBAppDetailCommon) GetCommunityVisibleStats() bool { + if m != nil && m.CommunityVisibleStats != nil { + return *m.CommunityVisibleStats + } + return false +} + +func (m *CCDDBAppDetailCommon) GetFriendlyName() string { + if m != nil && m.FriendlyName != nil { + return *m.FriendlyName + } + return "" +} + +func (m *CCDDBAppDetailCommon) GetPropagation() string { + if m != nil && m.Propagation != nil { + return *m.Propagation + } + return "" +} + +func (m *CCDDBAppDetailCommon) GetHasAdultContent() bool { + if m != nil && m.HasAdultContent != nil { + return *m.HasAdultContent + } + return false +} + +type CMsgAppRights struct { + EditInfo *bool `protobuf:"varint,1,opt,name=edit_info" json:"edit_info,omitempty"` + Publish *bool `protobuf:"varint,2,opt,name=publish" json:"publish,omitempty"` + ViewErrorData *bool `protobuf:"varint,3,opt,name=view_error_data" json:"view_error_data,omitempty"` + Download *bool `protobuf:"varint,4,opt,name=download" json:"download,omitempty"` + UploadCdkeys *bool `protobuf:"varint,5,opt,name=upload_cdkeys" json:"upload_cdkeys,omitempty"` + GenerateCdkeys *bool `protobuf:"varint,6,opt,name=generate_cdkeys" json:"generate_cdkeys,omitempty"` + ViewFinancials *bool `protobuf:"varint,7,opt,name=view_financials" json:"view_financials,omitempty"` + ManageCeg *bool `protobuf:"varint,8,opt,name=manage_ceg" json:"manage_ceg,omitempty"` + ManageSigning *bool `protobuf:"varint,9,opt,name=manage_signing" json:"manage_signing,omitempty"` + ManageCdkeys *bool `protobuf:"varint,10,opt,name=manage_cdkeys" json:"manage_cdkeys,omitempty"` + EditMarketing *bool `protobuf:"varint,11,opt,name=edit_marketing" json:"edit_marketing,omitempty"` + EconomySupport *bool `protobuf:"varint,12,opt,name=economy_support" json:"economy_support,omitempty"` + EconomySupportSupervisor *bool `protobuf:"varint,13,opt,name=economy_support_supervisor" json:"economy_support_supervisor,omitempty"` + ManagePricing *bool `protobuf:"varint,14,opt,name=manage_pricing" json:"manage_pricing,omitempty"` + BroadcastLive *bool `protobuf:"varint,15,opt,name=broadcast_live" json:"broadcast_live,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAppRights) Reset() { *m = CMsgAppRights{} } +func (m *CMsgAppRights) String() string { return proto.CompactTextString(m) } +func (*CMsgAppRights) ProtoMessage() {} +func (*CMsgAppRights) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{5} } + +func (m *CMsgAppRights) GetEditInfo() bool { + if m != nil && m.EditInfo != nil { + return *m.EditInfo + } + return false +} + +func (m *CMsgAppRights) GetPublish() bool { + if m != nil && m.Publish != nil { + return *m.Publish + } + return false +} + +func (m *CMsgAppRights) GetViewErrorData() bool { + if m != nil && m.ViewErrorData != nil { + return *m.ViewErrorData + } + return false +} + +func (m *CMsgAppRights) GetDownload() bool { + if m != nil && m.Download != nil { + return *m.Download + } + return false +} + +func (m *CMsgAppRights) GetUploadCdkeys() bool { + if m != nil && m.UploadCdkeys != nil { + return *m.UploadCdkeys + } + return false +} + +func (m *CMsgAppRights) GetGenerateCdkeys() bool { + if m != nil && m.GenerateCdkeys != nil { + return *m.GenerateCdkeys + } + return false +} + +func (m *CMsgAppRights) GetViewFinancials() bool { + if m != nil && m.ViewFinancials != nil { + return *m.ViewFinancials + } + return false +} + +func (m *CMsgAppRights) GetManageCeg() bool { + if m != nil && m.ManageCeg != nil { + return *m.ManageCeg + } + return false +} + +func (m *CMsgAppRights) GetManageSigning() bool { + if m != nil && m.ManageSigning != nil { + return *m.ManageSigning + } + return false +} + +func (m *CMsgAppRights) GetManageCdkeys() bool { + if m != nil && m.ManageCdkeys != nil { + return *m.ManageCdkeys + } + return false +} + +func (m *CMsgAppRights) GetEditMarketing() bool { + if m != nil && m.EditMarketing != nil { + return *m.EditMarketing + } + return false +} + +func (m *CMsgAppRights) GetEconomySupport() bool { + if m != nil && m.EconomySupport != nil { + return *m.EconomySupport + } + return false +} + +func (m *CMsgAppRights) GetEconomySupportSupervisor() bool { + if m != nil && m.EconomySupportSupervisor != nil { + return *m.EconomySupportSupervisor + } + return false +} + +func (m *CMsgAppRights) GetManagePricing() bool { + if m != nil && m.ManagePricing != nil { + return *m.ManagePricing + } + return false +} + +func (m *CMsgAppRights) GetBroadcastLive() bool { + if m != nil && m.BroadcastLive != nil { + return *m.BroadcastLive + } + return false +} + +var E_MsgpoolSoftLimit = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*int32)(nil), + Field: 50000, + Name: "msgpool_soft_limit", + Tag: "varint,50000,opt,name=msgpool_soft_limit,def=32", +} + +var E_MsgpoolHardLimit = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MessageOptions)(nil), + ExtensionType: (*int32)(nil), + Field: 50001, + Name: "msgpool_hard_limit", + Tag: "varint,50001,opt,name=msgpool_hard_limit,def=384", +} + +func init() { + proto.RegisterType((*CMsgProtoBufHeader)(nil), "CMsgProtoBufHeader") + proto.RegisterType((*CMsgMulti)(nil), "CMsgMulti") + proto.RegisterType((*CMsgProtobufWrapped)(nil), "CMsgProtobufWrapped") + proto.RegisterType((*CMsgAuthTicket)(nil), "CMsgAuthTicket") + proto.RegisterType((*CCDDBAppDetailCommon)(nil), "CCDDBAppDetailCommon") + proto.RegisterType((*CMsgAppRights)(nil), "CMsgAppRights") + proto.RegisterExtension(E_MsgpoolSoftLimit) + proto.RegisterExtension(E_MsgpoolHardLimit) +} + +var base_fileDescriptor0 = []byte{ + // 906 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x54, 0x4d, 0x6f, 0x1c, 0x45, + 0x10, 0x65, 0x77, 0xfd, 0x31, 0xdb, 0xde, 0x5d, 0xdb, 0x63, 0x27, 0xee, 0x98, 0x43, 0xa2, 0xbd, + 0x80, 0x40, 0x72, 0xe2, 0x78, 0x1d, 0x1b, 0xdf, 0xfc, 0x71, 0xc8, 0xc5, 0x02, 0x21, 0x24, 0x8e, + 0xad, 0x9e, 0x99, 0xda, 0xd9, 0xc6, 0x33, 0xdd, 0x4d, 0x77, 0x8f, 0xad, 0xcd, 0x89, 0x13, 0x57, + 0xfe, 0x1a, 0xfc, 0x12, 0x6e, 0x88, 0x23, 0xd5, 0x35, 0xb3, 0x38, 0x04, 0x81, 0x72, 0x1a, 0x55, + 0xd5, 0xeb, 0xaa, 0x57, 0xaf, 0xaa, 0x86, 0x71, 0x1f, 0x40, 0xd6, 0x35, 0x78, 0x2f, 0x4b, 0xf0, + 0x22, 0x93, 0x1e, 0x8e, 0xac, 0x33, 0xc1, 0x1c, 0xbe, 0x28, 0x8d, 0x29, 0x2b, 0x78, 0x49, 0x56, + 0xd6, 0xcc, 0x5f, 0x16, 0xe0, 0x73, 0xa7, 0x6c, 0x30, 0xae, 0x45, 0x4c, 0xff, 0x1c, 0xb0, 0xf4, + 0xfa, 0xd6, 0x97, 0xdf, 0x44, 0xeb, 0xaa, 0x99, 0xbf, 0x05, 0x59, 0x80, 0x4b, 0xb7, 0xd9, 0x26, + 0x25, 0x55, 0x05, 0xef, 0xbd, 0xe8, 0x7d, 0xbe, 0x91, 0x72, 0xb6, 0x93, 0x57, 0x0a, 0x74, 0x10, + 0x1e, 0xeb, 0x28, 0xa3, 0x31, 0xd2, 0xc7, 0xc8, 0x7a, 0xfa, 0x84, 0x8d, 0x9d, 0x69, 0x82, 0xd2, + 0xa5, 0x90, 0xd6, 0xa2, 0x7b, 0x80, 0xee, 0x71, 0xfa, 0x05, 0x1b, 0xfd, 0x60, 0x32, 0x55, 0x08, + 0x6f, 0x1a, 0x97, 0x03, 0x67, 0x31, 0xcd, 0xc5, 0xfe, 0xf1, 0xf9, 0x6c, 0xf6, 0xe6, 0x6c, 0x36, + 0x7b, 0x75, 0x76, 0x72, 0xf6, 0xea, 0xab, 0xd3, 0xd3, 0xe3, 0x37, 0xc7, 0xa7, 0x8f, 0xd8, 0x20, + 0x5d, 0x09, 0x81, 0x6f, 0xfd, 0x0f, 0xf6, 0x80, 0x6d, 0xb7, 0x28, 0x81, 0x4f, 0x84, 0x96, 0x35, + 0xf0, 0x11, 0xc2, 0x87, 0x44, 0x19, 0x7e, 0x14, 0xba, 0xa9, 0x39, 0x27, 0x62, 0x29, 0xdb, 0x04, + 0x07, 0xbe, 0xa9, 0x02, 0x1f, 0x47, 0xc7, 0x45, 0xef, 0x75, 0x24, 0x0b, 0xce, 0x19, 0x27, 0x3a, + 0xb5, 0xf8, 0x84, 0xde, 0x32, 0xd6, 0x57, 0x96, 0x6f, 0x13, 0xf1, 0x43, 0x96, 0xca, 0x26, 0x2c, + 0x84, 0xcc, 0x73, 0xd3, 0x60, 0xbf, 0xf3, 0x4a, 0x96, 0x9e, 0xef, 0x50, 0x6c, 0x9f, 0x8d, 0x82, + 0xb9, 0x03, 0xbd, 0x6a, 0xea, 0x29, 0x79, 0x3f, 0x65, 0x7b, 0xb2, 0xa8, 0x15, 0x7a, 0xad, 0x31, + 0xf3, 0x28, 0x44, 0xe3, 0xc1, 0xf1, 0x03, 0x0c, 0x26, 0x98, 0x6e, 0x3b, 0x38, 0xa9, 0x31, 0xe4, + 0x82, 0xa0, 0xda, 0x7c, 0xb7, 0x65, 0x73, 0x9c, 0x7e, 0xc6, 0x86, 0x1d, 0x0f, 0x94, 0x2d, 0x45, + 0xef, 0xda, 0x7f, 0x34, 0x8d, 0x9c, 0x6c, 0x93, 0x55, 0xca, 0x2f, 0xc0, 0x89, 0x12, 0xe5, 0xb6, + 0x02, 0x5f, 0xec, 0x51, 0xf5, 0x31, 0x5b, 0xf7, 0x4b, 0x8f, 0xe6, 0x3e, 0x99, 0xbb, 0x6c, 0x88, + 0xf5, 0x72, 0x40, 0x2d, 0x4b, 0xfe, 0x24, 0xe6, 0x8c, 0x4d, 0x3f, 0x40, 0x26, 0xad, 0x12, 0x77, + 0xb0, 0x8c, 0x0f, 0x9f, 0x45, 0xe4, 0xf4, 0x9c, 0x0d, 0xe3, 0xe4, 0x6f, 0x51, 0x20, 0x15, 0x31, + 0x5e, 0xbd, 0x03, 0xd1, 0xe8, 0x77, 0xca, 0x5a, 0x68, 0xc7, 0x4e, 0x0d, 0x77, 0x0c, 0x45, 0x66, + 0x8a, 0x25, 0x8d, 0x7c, 0x34, 0xfd, 0x92, 0xed, 0xfd, 0xbd, 0x33, 0xb8, 0x55, 0xdf, 0x3b, 0x19, + 0x9f, 0xfc, 0x0b, 0xdc, 0x23, 0xf0, 0x2f, 0x3d, 0x36, 0x89, 0xe8, 0x4b, 0x14, 0xf5, 0x3b, 0x95, + 0xdf, 0x41, 0x48, 0x27, 0x6c, 0x03, 0x7c, 0x90, 0x01, 0xba, 0x2a, 0xef, 0x4d, 0x2a, 0x16, 0x18, + 0xc7, 0x49, 0xbd, 0xb7, 0x81, 0x03, 0xda, 0x40, 0x7c, 0x54, 0xe2, 0xb4, 0xd1, 0x5e, 0x23, 0x1b, + 0xab, 0x2d, 0x04, 0x41, 0x84, 0x55, 0x16, 0xf8, 0x7a, 0x97, 0x8a, 0x05, 0x2a, 0x22, 0x72, 0x97, + 0xf3, 0x0d, 0xf2, 0xe1, 0xcb, 0xd6, 0xc7, 0x37, 0x89, 0xd1, 0x1f, 0x3d, 0xb6, 0x7f, 0x7d, 0x7d, + 0x73, 0x73, 0x75, 0x69, 0xed, 0x0d, 0x04, 0xa9, 0xaa, 0x6b, 0x53, 0xd7, 0x46, 0x47, 0x29, 0xdb, + 0x15, 0x6e, 0x69, 0x8d, 0xd8, 0x1a, 0xed, 0x57, 0x9f, 0x76, 0x04, 0x2d, 0x95, 0x1b, 0x4d, 0x6c, + 0xc8, 0xaa, 0x4c, 0x69, 0x88, 0xcb, 0x30, 0x56, 0x8d, 0x96, 0xf0, 0xb5, 0xac, 0x2a, 0x62, 0x42, + 0x88, 0x60, 0x4c, 0x45, 0x1c, 0x92, 0x68, 0x15, 0x50, 0x1b, 0x62, 0x90, 0xc4, 0x42, 0x35, 0x14, + 0x4a, 0xf2, 0x84, 0xcc, 0xe7, 0xec, 0x20, 0x47, 0x06, 0x8d, 0x56, 0x61, 0x29, 0xee, 0x95, 0x57, + 0x59, 0x05, 0x22, 0x0a, 0xe4, 0xf9, 0x90, 0x00, 0x38, 0x9d, 0xb9, 0xc3, 0xeb, 0x2b, 0xaa, 0x65, + 0xbb, 0xf2, 0x8c, 0x4a, 0xec, 0xb1, 0x2d, 0xbc, 0x62, 0x2b, 0x4b, 0x19, 0xf0, 0x22, 0xe9, 0x6c, + 0x86, 0xe9, 0x33, 0xb6, 0xbb, 0x90, 0x5e, 0xc8, 0x02, 0xe5, 0x14, 0x48, 0x38, 0xe0, 0xd1, 0xd2, + 0x89, 0x24, 0xd3, 0xdf, 0xfb, 0x6c, 0x4c, 0xa3, 0xb0, 0xf6, 0x5b, 0x55, 0x2e, 0x82, 0x8f, 0xdb, + 0x82, 0x3c, 0x82, 0x50, 0x7a, 0x6e, 0xa8, 0xeb, 0x24, 0x0a, 0xdf, 0xed, 0x1a, 0x35, 0x9e, 0xc4, + 0x8b, 0xbb, 0x57, 0xf0, 0xd0, 0x2e, 0xaf, 0x28, 0x64, 0x90, 0xa4, 0x41, 0x92, 0xee, 0xb0, 0xa4, + 0x30, 0x0f, 0xba, 0x32, 0xb2, 0x9d, 0x09, 0xf1, 0x6c, 0x6c, 0xb4, 0x45, 0x5e, 0xe0, 0xae, 0x79, + 0x92, 0x82, 0x32, 0x94, 0xa0, 0xc1, 0xe1, 0xc4, 0x57, 0x81, 0x8d, 0x7f, 0xa4, 0xc6, 0xa3, 0x91, + 0x3a, 0x57, 0xb2, 0xf2, 0x9d, 0x40, 0x28, 0x68, 0x2d, 0x75, 0xdc, 0xa4, 0x1c, 0xca, 0x4e, 0xa5, + 0xa7, 0x6c, 0xd2, 0xf9, 0xbc, 0x2a, 0x35, 0x9e, 0xd9, 0xa3, 0x38, 0x2b, 0x6c, 0x9b, 0x9b, 0xad, + 0xe0, 0xd4, 0x5a, 0x2d, 0x1d, 0x8e, 0x3e, 0xc2, 0xb7, 0x56, 0x35, 0x01, 0x65, 0x31, 0xf5, 0x52, + 0xf8, 0xc6, 0xc6, 0xb3, 0x6c, 0xd5, 0x49, 0xa7, 0xec, 0xf0, 0x83, 0x40, 0xfc, 0x82, 0xc3, 0x81, + 0xe0, 0xd1, 0x8e, 0x3f, 0xe0, 0x60, 0x9d, 0xca, 0x63, 0xd2, 0xc9, 0xca, 0x9f, 0x39, 0xec, 0x3b, + 0x97, 0x3e, 0x88, 0x4a, 0xdd, 0x03, 0xfd, 0x4c, 0x92, 0x8b, 0x4b, 0x96, 0xd6, 0xbe, 0xc4, 0xdf, + 0x42, 0x85, 0xbf, 0x8c, 0x79, 0x0c, 0xd5, 0x2a, 0xa4, 0xcf, 0x8f, 0xda, 0xff, 0xf2, 0xd1, 0xea, + 0xbf, 0x7c, 0x74, 0xdb, 0xde, 0xcd, 0xd7, 0x36, 0x0e, 0xd2, 0xf3, 0x5f, 0x7f, 0x1e, 0xd0, 0x3f, + 0xa2, 0x7f, 0xf2, 0xfa, 0xe2, 0xea, 0x31, 0xc5, 0x42, 0xba, 0xe2, 0x63, 0x53, 0xfc, 0xd6, 0xa5, + 0x18, 0x9c, 0x9c, 0xcf, 0xae, 0xd6, 0xdf, 0xf6, 0x7e, 0xea, 0x7d, 0xf2, 0x57, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x66, 0x1a, 0xa6, 0xfc, 0x29, 0x06, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/client_server.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/client_server.pb.go new file mode 100644 index 00000000..6a663880 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/client_server.pb.go @@ -0,0 +1,9259 @@ +// Code generated by protoc-gen-go. +// source: steammessages_clientserver.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CMsgClientHeartBeat struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientHeartBeat) Reset() { *m = CMsgClientHeartBeat{} } +func (m *CMsgClientHeartBeat) String() string { return proto.CompactTextString(m) } +func (*CMsgClientHeartBeat) ProtoMessage() {} +func (*CMsgClientHeartBeat) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{0} } + +type CMsgClientUDSP2PSessionStarted struct { + SteamidRemote *uint64 `protobuf:"fixed64,1,opt,name=steamid_remote" json:"steamid_remote,omitempty"` + Appid *int32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUDSP2PSessionStarted) Reset() { *m = CMsgClientUDSP2PSessionStarted{} } +func (m *CMsgClientUDSP2PSessionStarted) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUDSP2PSessionStarted) ProtoMessage() {} +func (*CMsgClientUDSP2PSessionStarted) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{1} } + +func (m *CMsgClientUDSP2PSessionStarted) GetSteamidRemote() uint64 { + if m != nil && m.SteamidRemote != nil { + return *m.SteamidRemote + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionStarted) GetAppid() int32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CMsgClientUDSP2PSessionEnded struct { + SteamidRemote *uint64 `protobuf:"fixed64,1,opt,name=steamid_remote" json:"steamid_remote,omitempty"` + Appid *int32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + SessionLengthSec *int32 `protobuf:"varint,3,opt,name=session_length_sec" json:"session_length_sec,omitempty"` + SessionError *int32 `protobuf:"varint,4,opt,name=session_error" json:"session_error,omitempty"` + Nattype *int32 `protobuf:"varint,5,opt,name=nattype" json:"nattype,omitempty"` + BytesRecv *int32 `protobuf:"varint,6,opt,name=bytes_recv" json:"bytes_recv,omitempty"` + BytesSent *int32 `protobuf:"varint,7,opt,name=bytes_sent" json:"bytes_sent,omitempty"` + BytesSentRelay *int32 `protobuf:"varint,8,opt,name=bytes_sent_relay" json:"bytes_sent_relay,omitempty"` + BytesRecvRelay *int32 `protobuf:"varint,9,opt,name=bytes_recv_relay" json:"bytes_recv_relay,omitempty"` + TimeToConnectMs *int32 `protobuf:"varint,10,opt,name=time_to_connect_ms" json:"time_to_connect_ms,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUDSP2PSessionEnded) Reset() { *m = CMsgClientUDSP2PSessionEnded{} } +func (m *CMsgClientUDSP2PSessionEnded) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUDSP2PSessionEnded) ProtoMessage() {} +func (*CMsgClientUDSP2PSessionEnded) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{2} } + +func (m *CMsgClientUDSP2PSessionEnded) GetSteamidRemote() uint64 { + if m != nil && m.SteamidRemote != nil { + return *m.SteamidRemote + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetAppid() int32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetSessionLengthSec() int32 { + if m != nil && m.SessionLengthSec != nil { + return *m.SessionLengthSec + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetSessionError() int32 { + if m != nil && m.SessionError != nil { + return *m.SessionError + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetNattype() int32 { + if m != nil && m.Nattype != nil { + return *m.Nattype + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetBytesRecv() int32 { + if m != nil && m.BytesRecv != nil { + return *m.BytesRecv + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetBytesSent() int32 { + if m != nil && m.BytesSent != nil { + return *m.BytesSent + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetBytesSentRelay() int32 { + if m != nil && m.BytesSentRelay != nil { + return *m.BytesSentRelay + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetBytesRecvRelay() int32 { + if m != nil && m.BytesRecvRelay != nil { + return *m.BytesRecvRelay + } + return 0 +} + +func (m *CMsgClientUDSP2PSessionEnded) GetTimeToConnectMs() int32 { + if m != nil && m.TimeToConnectMs != nil { + return *m.TimeToConnectMs + } + return 0 +} + +type CMsgClientRegisterAuthTicketWithCM struct { + ProtocolVersion *uint32 `protobuf:"varint,1,opt,name=protocol_version" json:"protocol_version,omitempty"` + Ticket []byte `protobuf:"bytes,3,opt,name=ticket" json:"ticket,omitempty"` + ClientInstanceId *uint64 `protobuf:"varint,4,opt,name=client_instance_id" json:"client_instance_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRegisterAuthTicketWithCM) Reset() { *m = CMsgClientRegisterAuthTicketWithCM{} } +func (m *CMsgClientRegisterAuthTicketWithCM) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRegisterAuthTicketWithCM) ProtoMessage() {} +func (*CMsgClientRegisterAuthTicketWithCM) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{3} +} + +func (m *CMsgClientRegisterAuthTicketWithCM) GetProtocolVersion() uint32 { + if m != nil && m.ProtocolVersion != nil { + return *m.ProtocolVersion + } + return 0 +} + +func (m *CMsgClientRegisterAuthTicketWithCM) GetTicket() []byte { + if m != nil { + return m.Ticket + } + return nil +} + +func (m *CMsgClientRegisterAuthTicketWithCM) GetClientInstanceId() uint64 { + if m != nil && m.ClientInstanceId != nil { + return *m.ClientInstanceId + } + return 0 +} + +type CMsgClientTicketAuthComplete struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + GameId *uint64 `protobuf:"fixed64,2,opt,name=game_id" json:"game_id,omitempty"` + Estate *uint32 `protobuf:"varint,3,opt,name=estate" json:"estate,omitempty"` + EauthSessionResponse *uint32 `protobuf:"varint,4,opt,name=eauth_session_response" json:"eauth_session_response,omitempty"` + DEPRECATEDTicket []byte `protobuf:"bytes,5,opt,name=DEPRECATED_ticket" json:"DEPRECATED_ticket,omitempty"` + TicketCrc *uint32 `protobuf:"varint,6,opt,name=ticket_crc" json:"ticket_crc,omitempty"` + TicketSequence *uint32 `protobuf:"varint,7,opt,name=ticket_sequence" json:"ticket_sequence,omitempty"` + OwnerSteamId *uint64 `protobuf:"fixed64,8,opt,name=owner_steam_id" json:"owner_steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientTicketAuthComplete) Reset() { *m = CMsgClientTicketAuthComplete{} } +func (m *CMsgClientTicketAuthComplete) String() string { return proto.CompactTextString(m) } +func (*CMsgClientTicketAuthComplete) ProtoMessage() {} +func (*CMsgClientTicketAuthComplete) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{4} } + +func (m *CMsgClientTicketAuthComplete) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgClientTicketAuthComplete) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientTicketAuthComplete) GetEstate() uint32 { + if m != nil && m.Estate != nil { + return *m.Estate + } + return 0 +} + +func (m *CMsgClientTicketAuthComplete) GetEauthSessionResponse() uint32 { + if m != nil && m.EauthSessionResponse != nil { + return *m.EauthSessionResponse + } + return 0 +} + +func (m *CMsgClientTicketAuthComplete) GetDEPRECATEDTicket() []byte { + if m != nil { + return m.DEPRECATEDTicket + } + return nil +} + +func (m *CMsgClientTicketAuthComplete) GetTicketCrc() uint32 { + if m != nil && m.TicketCrc != nil { + return *m.TicketCrc + } + return 0 +} + +func (m *CMsgClientTicketAuthComplete) GetTicketSequence() uint32 { + if m != nil && m.TicketSequence != nil { + return *m.TicketSequence + } + return 0 +} + +func (m *CMsgClientTicketAuthComplete) GetOwnerSteamId() uint64 { + if m != nil && m.OwnerSteamId != nil { + return *m.OwnerSteamId + } + return 0 +} + +type CMsgClientLogon struct { + ProtocolVersion *uint32 `protobuf:"varint,1,opt,name=protocol_version" json:"protocol_version,omitempty"` + ObfustucatedPrivateIp *uint32 `protobuf:"varint,2,opt,name=obfustucated_private_ip" json:"obfustucated_private_ip,omitempty"` + CellId *uint32 `protobuf:"varint,3,opt,name=cell_id" json:"cell_id,omitempty"` + LastSessionId *uint32 `protobuf:"varint,4,opt,name=last_session_id" json:"last_session_id,omitempty"` + ClientPackageVersion *uint32 `protobuf:"varint,5,opt,name=client_package_version" json:"client_package_version,omitempty"` + ClientLanguage *string `protobuf:"bytes,6,opt,name=client_language" json:"client_language,omitempty"` + ClientOsType *uint32 `protobuf:"varint,7,opt,name=client_os_type" json:"client_os_type,omitempty"` + ShouldRememberPassword *bool `protobuf:"varint,8,opt,name=should_remember_password,def=0" json:"should_remember_password,omitempty"` + WineVersion *string `protobuf:"bytes,9,opt,name=wine_version" json:"wine_version,omitempty"` + PingMsFromCellSearch *uint32 `protobuf:"varint,10,opt,name=ping_ms_from_cell_search" json:"ping_ms_from_cell_search,omitempty"` + PublicIp *uint32 `protobuf:"varint,20,opt,name=public_ip" json:"public_ip,omitempty"` + QosLevel *uint32 `protobuf:"varint,21,opt,name=qos_level" json:"qos_level,omitempty"` + ClientSuppliedSteamId *uint64 `protobuf:"fixed64,22,opt,name=client_supplied_steam_id" json:"client_supplied_steam_id,omitempty"` + MachineId []byte `protobuf:"bytes,30,opt,name=machine_id" json:"machine_id,omitempty"` + LauncherType *uint32 `protobuf:"varint,31,opt,name=launcher_type,def=0" json:"launcher_type,omitempty"` + UiMode *uint32 `protobuf:"varint,32,opt,name=ui_mode,def=0" json:"ui_mode,omitempty"` + Steam2AuthTicket []byte `protobuf:"bytes,41,opt,name=steam2_auth_ticket" json:"steam2_auth_ticket,omitempty"` + EmailAddress *string `protobuf:"bytes,42,opt,name=email_address" json:"email_address,omitempty"` + Rtime32AccountCreation *uint32 `protobuf:"fixed32,43,opt,name=rtime32_account_creation" json:"rtime32_account_creation,omitempty"` + AccountName *string `protobuf:"bytes,50,opt,name=account_name" json:"account_name,omitempty"` + Password *string `protobuf:"bytes,51,opt,name=password" json:"password,omitempty"` + GameServerToken *string `protobuf:"bytes,52,opt,name=game_server_token" json:"game_server_token,omitempty"` + LoginKey *string `protobuf:"bytes,60,opt,name=login_key" json:"login_key,omitempty"` + WasConvertedDeprecatedMsg *bool `protobuf:"varint,70,opt,name=was_converted_deprecated_msg,def=0" json:"was_converted_deprecated_msg,omitempty"` + AnonUserTargetAccountName *string `protobuf:"bytes,80,opt,name=anon_user_target_account_name" json:"anon_user_target_account_name,omitempty"` + ResolvedUserSteamId *uint64 `protobuf:"fixed64,81,opt,name=resolved_user_steam_id" json:"resolved_user_steam_id,omitempty"` + EresultSentryfile *int32 `protobuf:"varint,82,opt,name=eresult_sentryfile" json:"eresult_sentryfile,omitempty"` + ShaSentryfile []byte `protobuf:"bytes,83,opt,name=sha_sentryfile" json:"sha_sentryfile,omitempty"` + AuthCode *string `protobuf:"bytes,84,opt,name=auth_code" json:"auth_code,omitempty"` + OtpType *int32 `protobuf:"varint,85,opt,name=otp_type" json:"otp_type,omitempty"` + OtpValue *uint32 `protobuf:"varint,86,opt,name=otp_value" json:"otp_value,omitempty"` + OtpIdentifier *string `protobuf:"bytes,87,opt,name=otp_identifier" json:"otp_identifier,omitempty"` + Steam2TicketRequest *bool `protobuf:"varint,88,opt,name=steam2_ticket_request" json:"steam2_ticket_request,omitempty"` + SonyPsnTicket []byte `protobuf:"bytes,90,opt,name=sony_psn_ticket" json:"sony_psn_ticket,omitempty"` + SonyPsnServiceId *string `protobuf:"bytes,91,opt,name=sony_psn_service_id" json:"sony_psn_service_id,omitempty"` + CreateNewPsnLinkedAccountIfNeeded *bool `protobuf:"varint,92,opt,name=create_new_psn_linked_account_if_needed,def=0" json:"create_new_psn_linked_account_if_needed,omitempty"` + SonyPsnName *string `protobuf:"bytes,93,opt,name=sony_psn_name" json:"sony_psn_name,omitempty"` + GameServerAppId *int32 `protobuf:"varint,94,opt,name=game_server_app_id" json:"game_server_app_id,omitempty"` + SteamguardDontRememberComputer *bool `protobuf:"varint,95,opt,name=steamguard_dont_remember_computer" json:"steamguard_dont_remember_computer,omitempty"` + MachineName *string `protobuf:"bytes,96,opt,name=machine_name" json:"machine_name,omitempty"` + MachineNameUserchosen *string `protobuf:"bytes,97,opt,name=machine_name_userchosen" json:"machine_name_userchosen,omitempty"` + CountryOverride *string `protobuf:"bytes,98,opt,name=country_override" json:"country_override,omitempty"` + IsSteamBox *bool `protobuf:"varint,99,opt,name=is_steam_box" json:"is_steam_box,omitempty"` + ClientInstanceId *uint64 `protobuf:"varint,100,opt,name=client_instance_id" json:"client_instance_id,omitempty"` + TwoFactorCode *string `protobuf:"bytes,101,opt,name=two_factor_code" json:"two_factor_code,omitempty"` + SupportsRateLimitResponse *bool `protobuf:"varint,102,opt,name=supports_rate_limit_response" json:"supports_rate_limit_response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLogon) Reset() { *m = CMsgClientLogon{} } +func (m *CMsgClientLogon) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLogon) ProtoMessage() {} +func (*CMsgClientLogon) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{5} } + +const Default_CMsgClientLogon_ShouldRememberPassword bool = false +const Default_CMsgClientLogon_LauncherType uint32 = 0 +const Default_CMsgClientLogon_UiMode uint32 = 0 +const Default_CMsgClientLogon_WasConvertedDeprecatedMsg bool = false +const Default_CMsgClientLogon_CreateNewPsnLinkedAccountIfNeeded bool = false + +func (m *CMsgClientLogon) GetProtocolVersion() uint32 { + if m != nil && m.ProtocolVersion != nil { + return *m.ProtocolVersion + } + return 0 +} + +func (m *CMsgClientLogon) GetObfustucatedPrivateIp() uint32 { + if m != nil && m.ObfustucatedPrivateIp != nil { + return *m.ObfustucatedPrivateIp + } + return 0 +} + +func (m *CMsgClientLogon) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CMsgClientLogon) GetLastSessionId() uint32 { + if m != nil && m.LastSessionId != nil { + return *m.LastSessionId + } + return 0 +} + +func (m *CMsgClientLogon) GetClientPackageVersion() uint32 { + if m != nil && m.ClientPackageVersion != nil { + return *m.ClientPackageVersion + } + return 0 +} + +func (m *CMsgClientLogon) GetClientLanguage() string { + if m != nil && m.ClientLanguage != nil { + return *m.ClientLanguage + } + return "" +} + +func (m *CMsgClientLogon) GetClientOsType() uint32 { + if m != nil && m.ClientOsType != nil { + return *m.ClientOsType + } + return 0 +} + +func (m *CMsgClientLogon) GetShouldRememberPassword() bool { + if m != nil && m.ShouldRememberPassword != nil { + return *m.ShouldRememberPassword + } + return Default_CMsgClientLogon_ShouldRememberPassword +} + +func (m *CMsgClientLogon) GetWineVersion() string { + if m != nil && m.WineVersion != nil { + return *m.WineVersion + } + return "" +} + +func (m *CMsgClientLogon) GetPingMsFromCellSearch() uint32 { + if m != nil && m.PingMsFromCellSearch != nil { + return *m.PingMsFromCellSearch + } + return 0 +} + +func (m *CMsgClientLogon) GetPublicIp() uint32 { + if m != nil && m.PublicIp != nil { + return *m.PublicIp + } + return 0 +} + +func (m *CMsgClientLogon) GetQosLevel() uint32 { + if m != nil && m.QosLevel != nil { + return *m.QosLevel + } + return 0 +} + +func (m *CMsgClientLogon) GetClientSuppliedSteamId() uint64 { + if m != nil && m.ClientSuppliedSteamId != nil { + return *m.ClientSuppliedSteamId + } + return 0 +} + +func (m *CMsgClientLogon) GetMachineId() []byte { + if m != nil { + return m.MachineId + } + return nil +} + +func (m *CMsgClientLogon) GetLauncherType() uint32 { + if m != nil && m.LauncherType != nil { + return *m.LauncherType + } + return Default_CMsgClientLogon_LauncherType +} + +func (m *CMsgClientLogon) GetUiMode() uint32 { + if m != nil && m.UiMode != nil { + return *m.UiMode + } + return Default_CMsgClientLogon_UiMode +} + +func (m *CMsgClientLogon) GetSteam2AuthTicket() []byte { + if m != nil { + return m.Steam2AuthTicket + } + return nil +} + +func (m *CMsgClientLogon) GetEmailAddress() string { + if m != nil && m.EmailAddress != nil { + return *m.EmailAddress + } + return "" +} + +func (m *CMsgClientLogon) GetRtime32AccountCreation() uint32 { + if m != nil && m.Rtime32AccountCreation != nil { + return *m.Rtime32AccountCreation + } + return 0 +} + +func (m *CMsgClientLogon) GetAccountName() string { + if m != nil && m.AccountName != nil { + return *m.AccountName + } + return "" +} + +func (m *CMsgClientLogon) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CMsgClientLogon) GetGameServerToken() string { + if m != nil && m.GameServerToken != nil { + return *m.GameServerToken + } + return "" +} + +func (m *CMsgClientLogon) GetLoginKey() string { + if m != nil && m.LoginKey != nil { + return *m.LoginKey + } + return "" +} + +func (m *CMsgClientLogon) GetWasConvertedDeprecatedMsg() bool { + if m != nil && m.WasConvertedDeprecatedMsg != nil { + return *m.WasConvertedDeprecatedMsg + } + return Default_CMsgClientLogon_WasConvertedDeprecatedMsg +} + +func (m *CMsgClientLogon) GetAnonUserTargetAccountName() string { + if m != nil && m.AnonUserTargetAccountName != nil { + return *m.AnonUserTargetAccountName + } + return "" +} + +func (m *CMsgClientLogon) GetResolvedUserSteamId() uint64 { + if m != nil && m.ResolvedUserSteamId != nil { + return *m.ResolvedUserSteamId + } + return 0 +} + +func (m *CMsgClientLogon) GetEresultSentryfile() int32 { + if m != nil && m.EresultSentryfile != nil { + return *m.EresultSentryfile + } + return 0 +} + +func (m *CMsgClientLogon) GetShaSentryfile() []byte { + if m != nil { + return m.ShaSentryfile + } + return nil +} + +func (m *CMsgClientLogon) GetAuthCode() string { + if m != nil && m.AuthCode != nil { + return *m.AuthCode + } + return "" +} + +func (m *CMsgClientLogon) GetOtpType() int32 { + if m != nil && m.OtpType != nil { + return *m.OtpType + } + return 0 +} + +func (m *CMsgClientLogon) GetOtpValue() uint32 { + if m != nil && m.OtpValue != nil { + return *m.OtpValue + } + return 0 +} + +func (m *CMsgClientLogon) GetOtpIdentifier() string { + if m != nil && m.OtpIdentifier != nil { + return *m.OtpIdentifier + } + return "" +} + +func (m *CMsgClientLogon) GetSteam2TicketRequest() bool { + if m != nil && m.Steam2TicketRequest != nil { + return *m.Steam2TicketRequest + } + return false +} + +func (m *CMsgClientLogon) GetSonyPsnTicket() []byte { + if m != nil { + return m.SonyPsnTicket + } + return nil +} + +func (m *CMsgClientLogon) GetSonyPsnServiceId() string { + if m != nil && m.SonyPsnServiceId != nil { + return *m.SonyPsnServiceId + } + return "" +} + +func (m *CMsgClientLogon) GetCreateNewPsnLinkedAccountIfNeeded() bool { + if m != nil && m.CreateNewPsnLinkedAccountIfNeeded != nil { + return *m.CreateNewPsnLinkedAccountIfNeeded + } + return Default_CMsgClientLogon_CreateNewPsnLinkedAccountIfNeeded +} + +func (m *CMsgClientLogon) GetSonyPsnName() string { + if m != nil && m.SonyPsnName != nil { + return *m.SonyPsnName + } + return "" +} + +func (m *CMsgClientLogon) GetGameServerAppId() int32 { + if m != nil && m.GameServerAppId != nil { + return *m.GameServerAppId + } + return 0 +} + +func (m *CMsgClientLogon) GetSteamguardDontRememberComputer() bool { + if m != nil && m.SteamguardDontRememberComputer != nil { + return *m.SteamguardDontRememberComputer + } + return false +} + +func (m *CMsgClientLogon) GetMachineName() string { + if m != nil && m.MachineName != nil { + return *m.MachineName + } + return "" +} + +func (m *CMsgClientLogon) GetMachineNameUserchosen() string { + if m != nil && m.MachineNameUserchosen != nil { + return *m.MachineNameUserchosen + } + return "" +} + +func (m *CMsgClientLogon) GetCountryOverride() string { + if m != nil && m.CountryOverride != nil { + return *m.CountryOverride + } + return "" +} + +func (m *CMsgClientLogon) GetIsSteamBox() bool { + if m != nil && m.IsSteamBox != nil { + return *m.IsSteamBox + } + return false +} + +func (m *CMsgClientLogon) GetClientInstanceId() uint64 { + if m != nil && m.ClientInstanceId != nil { + return *m.ClientInstanceId + } + return 0 +} + +func (m *CMsgClientLogon) GetTwoFactorCode() string { + if m != nil && m.TwoFactorCode != nil { + return *m.TwoFactorCode + } + return "" +} + +func (m *CMsgClientLogon) GetSupportsRateLimitResponse() bool { + if m != nil && m.SupportsRateLimitResponse != nil { + return *m.SupportsRateLimitResponse + } + return false +} + +type CMsgClientLogonResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + OutOfGameHeartbeatSeconds *int32 `protobuf:"varint,2,opt,name=out_of_game_heartbeat_seconds" json:"out_of_game_heartbeat_seconds,omitempty"` + InGameHeartbeatSeconds *int32 `protobuf:"varint,3,opt,name=in_game_heartbeat_seconds" json:"in_game_heartbeat_seconds,omitempty"` + PublicIp *uint32 `protobuf:"varint,4,opt,name=public_ip" json:"public_ip,omitempty"` + Rtime32ServerTime *uint32 `protobuf:"fixed32,5,opt,name=rtime32_server_time" json:"rtime32_server_time,omitempty"` + AccountFlags *uint32 `protobuf:"varint,6,opt,name=account_flags" json:"account_flags,omitempty"` + CellId *uint32 `protobuf:"varint,7,opt,name=cell_id" json:"cell_id,omitempty"` + EmailDomain *string `protobuf:"bytes,8,opt,name=email_domain" json:"email_domain,omitempty"` + Steam2Ticket []byte `protobuf:"bytes,9,opt,name=steam2_ticket" json:"steam2_ticket,omitempty"` + EresultExtended *int32 `protobuf:"varint,10,opt,name=eresult_extended" json:"eresult_extended,omitempty"` + WebapiAuthenticateUserNonce *string `protobuf:"bytes,11,opt,name=webapi_authenticate_user_nonce" json:"webapi_authenticate_user_nonce,omitempty"` + CellIdPingThreshold *uint32 `protobuf:"varint,12,opt,name=cell_id_ping_threshold" json:"cell_id_ping_threshold,omitempty"` + UsePics *bool `protobuf:"varint,13,opt,name=use_pics" json:"use_pics,omitempty"` + VanityUrl *string `protobuf:"bytes,14,opt,name=vanity_url" json:"vanity_url,omitempty"` + ClientSuppliedSteamid *uint64 `protobuf:"fixed64,20,opt,name=client_supplied_steamid" json:"client_supplied_steamid,omitempty"` + IpCountryCode *string `protobuf:"bytes,21,opt,name=ip_country_code" json:"ip_country_code,omitempty"` + ParentalSettings []byte `protobuf:"bytes,22,opt,name=parental_settings" json:"parental_settings,omitempty"` + ParentalSettingSignature []byte `protobuf:"bytes,23,opt,name=parental_setting_signature" json:"parental_setting_signature,omitempty"` + CountLoginfailuresToMigrate *int32 `protobuf:"varint,24,opt,name=count_loginfailures_to_migrate" json:"count_loginfailures_to_migrate,omitempty"` + CountDisconnectsToMigrate *int32 `protobuf:"varint,25,opt,name=count_disconnects_to_migrate" json:"count_disconnects_to_migrate,omitempty"` + OgsDataReportTimeWindow *int32 `protobuf:"varint,26,opt,name=ogs_data_report_time_window" json:"ogs_data_report_time_window,omitempty"` + ClientInstanceId *uint64 `protobuf:"varint,27,opt,name=client_instance_id" json:"client_instance_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLogonResponse) Reset() { *m = CMsgClientLogonResponse{} } +func (m *CMsgClientLogonResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLogonResponse) ProtoMessage() {} +func (*CMsgClientLogonResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{6} } + +const Default_CMsgClientLogonResponse_Eresult int32 = 2 + +func (m *CMsgClientLogonResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientLogonResponse_Eresult +} + +func (m *CMsgClientLogonResponse) GetOutOfGameHeartbeatSeconds() int32 { + if m != nil && m.OutOfGameHeartbeatSeconds != nil { + return *m.OutOfGameHeartbeatSeconds + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetInGameHeartbeatSeconds() int32 { + if m != nil && m.InGameHeartbeatSeconds != nil { + return *m.InGameHeartbeatSeconds + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetPublicIp() uint32 { + if m != nil && m.PublicIp != nil { + return *m.PublicIp + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetRtime32ServerTime() uint32 { + if m != nil && m.Rtime32ServerTime != nil { + return *m.Rtime32ServerTime + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetAccountFlags() uint32 { + if m != nil && m.AccountFlags != nil { + return *m.AccountFlags + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetEmailDomain() string { + if m != nil && m.EmailDomain != nil { + return *m.EmailDomain + } + return "" +} + +func (m *CMsgClientLogonResponse) GetSteam2Ticket() []byte { + if m != nil { + return m.Steam2Ticket + } + return nil +} + +func (m *CMsgClientLogonResponse) GetEresultExtended() int32 { + if m != nil && m.EresultExtended != nil { + return *m.EresultExtended + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetWebapiAuthenticateUserNonce() string { + if m != nil && m.WebapiAuthenticateUserNonce != nil { + return *m.WebapiAuthenticateUserNonce + } + return "" +} + +func (m *CMsgClientLogonResponse) GetCellIdPingThreshold() uint32 { + if m != nil && m.CellIdPingThreshold != nil { + return *m.CellIdPingThreshold + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetUsePics() bool { + if m != nil && m.UsePics != nil { + return *m.UsePics + } + return false +} + +func (m *CMsgClientLogonResponse) GetVanityUrl() string { + if m != nil && m.VanityUrl != nil { + return *m.VanityUrl + } + return "" +} + +func (m *CMsgClientLogonResponse) GetClientSuppliedSteamid() uint64 { + if m != nil && m.ClientSuppliedSteamid != nil { + return *m.ClientSuppliedSteamid + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetIpCountryCode() string { + if m != nil && m.IpCountryCode != nil { + return *m.IpCountryCode + } + return "" +} + +func (m *CMsgClientLogonResponse) GetParentalSettings() []byte { + if m != nil { + return m.ParentalSettings + } + return nil +} + +func (m *CMsgClientLogonResponse) GetParentalSettingSignature() []byte { + if m != nil { + return m.ParentalSettingSignature + } + return nil +} + +func (m *CMsgClientLogonResponse) GetCountLoginfailuresToMigrate() int32 { + if m != nil && m.CountLoginfailuresToMigrate != nil { + return *m.CountLoginfailuresToMigrate + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetCountDisconnectsToMigrate() int32 { + if m != nil && m.CountDisconnectsToMigrate != nil { + return *m.CountDisconnectsToMigrate + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetOgsDataReportTimeWindow() int32 { + if m != nil && m.OgsDataReportTimeWindow != nil { + return *m.OgsDataReportTimeWindow + } + return 0 +} + +func (m *CMsgClientLogonResponse) GetClientInstanceId() uint64 { + if m != nil && m.ClientInstanceId != nil { + return *m.ClientInstanceId + } + return 0 +} + +type CMsgClientRequestWebAPIAuthenticateUserNonce struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestWebAPIAuthenticateUserNonce) Reset() { + *m = CMsgClientRequestWebAPIAuthenticateUserNonce{} +} +func (m *CMsgClientRequestWebAPIAuthenticateUserNonce) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientRequestWebAPIAuthenticateUserNonce) ProtoMessage() {} +func (*CMsgClientRequestWebAPIAuthenticateUserNonce) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{7} +} + +type CMsgClientRequestWebAPIAuthenticateUserNonceResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + WebapiAuthenticateUserNonce *string `protobuf:"bytes,11,opt,name=webapi_authenticate_user_nonce" json:"webapi_authenticate_user_nonce,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestWebAPIAuthenticateUserNonceResponse) Reset() { + *m = CMsgClientRequestWebAPIAuthenticateUserNonceResponse{} +} +func (m *CMsgClientRequestWebAPIAuthenticateUserNonceResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientRequestWebAPIAuthenticateUserNonceResponse) ProtoMessage() {} +func (*CMsgClientRequestWebAPIAuthenticateUserNonceResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{8} +} + +const Default_CMsgClientRequestWebAPIAuthenticateUserNonceResponse_Eresult int32 = 2 + +func (m *CMsgClientRequestWebAPIAuthenticateUserNonceResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientRequestWebAPIAuthenticateUserNonceResponse_Eresult +} + +func (m *CMsgClientRequestWebAPIAuthenticateUserNonceResponse) GetWebapiAuthenticateUserNonce() string { + if m != nil && m.WebapiAuthenticateUserNonce != nil { + return *m.WebapiAuthenticateUserNonce + } + return "" +} + +type CMsgClientLogOff struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLogOff) Reset() { *m = CMsgClientLogOff{} } +func (m *CMsgClientLogOff) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLogOff) ProtoMessage() {} +func (*CMsgClientLogOff) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{9} } + +type CMsgClientLoggedOff struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLoggedOff) Reset() { *m = CMsgClientLoggedOff{} } +func (m *CMsgClientLoggedOff) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLoggedOff) ProtoMessage() {} +func (*CMsgClientLoggedOff) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{10} } + +const Default_CMsgClientLoggedOff_Eresult int32 = 2 + +func (m *CMsgClientLoggedOff) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientLoggedOff_Eresult +} + +type CMsgClientCMList struct { + CmAddresses []uint32 `protobuf:"varint,1,rep,name=cm_addresses" json:"cm_addresses,omitempty"` + CmPorts []uint32 `protobuf:"varint,2,rep,name=cm_ports" json:"cm_ports,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCMList) Reset() { *m = CMsgClientCMList{} } +func (m *CMsgClientCMList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCMList) ProtoMessage() {} +func (*CMsgClientCMList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{11} } + +func (m *CMsgClientCMList) GetCmAddresses() []uint32 { + if m != nil { + return m.CmAddresses + } + return nil +} + +func (m *CMsgClientCMList) GetCmPorts() []uint32 { + if m != nil { + return m.CmPorts + } + return nil +} + +type CMsgClientP2PConnectionInfo struct { + SteamIdDest *uint64 `protobuf:"fixed64,1,opt,name=steam_id_dest" json:"steam_id_dest,omitempty"` + SteamIdSrc *uint64 `protobuf:"fixed64,2,opt,name=steam_id_src" json:"steam_id_src,omitempty"` + AppId *uint32 `protobuf:"varint,3,opt,name=app_id" json:"app_id,omitempty"` + Candidate []byte `protobuf:"bytes,4,opt,name=candidate" json:"candidate,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientP2PConnectionInfo) Reset() { *m = CMsgClientP2PConnectionInfo{} } +func (m *CMsgClientP2PConnectionInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientP2PConnectionInfo) ProtoMessage() {} +func (*CMsgClientP2PConnectionInfo) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{12} } + +func (m *CMsgClientP2PConnectionInfo) GetSteamIdDest() uint64 { + if m != nil && m.SteamIdDest != nil { + return *m.SteamIdDest + } + return 0 +} + +func (m *CMsgClientP2PConnectionInfo) GetSteamIdSrc() uint64 { + if m != nil && m.SteamIdSrc != nil { + return *m.SteamIdSrc + } + return 0 +} + +func (m *CMsgClientP2PConnectionInfo) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientP2PConnectionInfo) GetCandidate() []byte { + if m != nil { + return m.Candidate + } + return nil +} + +type CMsgClientP2PConnectionFailInfo struct { + SteamIdDest *uint64 `protobuf:"fixed64,1,opt,name=steam_id_dest" json:"steam_id_dest,omitempty"` + SteamIdSrc *uint64 `protobuf:"fixed64,2,opt,name=steam_id_src" json:"steam_id_src,omitempty"` + AppId *uint32 `protobuf:"varint,3,opt,name=app_id" json:"app_id,omitempty"` + Ep2PSessionError *uint32 `protobuf:"varint,4,opt,name=ep2p_session_error" json:"ep2p_session_error,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientP2PConnectionFailInfo) Reset() { *m = CMsgClientP2PConnectionFailInfo{} } +func (m *CMsgClientP2PConnectionFailInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientP2PConnectionFailInfo) ProtoMessage() {} +func (*CMsgClientP2PConnectionFailInfo) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{13} +} + +func (m *CMsgClientP2PConnectionFailInfo) GetSteamIdDest() uint64 { + if m != nil && m.SteamIdDest != nil { + return *m.SteamIdDest + } + return 0 +} + +func (m *CMsgClientP2PConnectionFailInfo) GetSteamIdSrc() uint64 { + if m != nil && m.SteamIdSrc != nil { + return *m.SteamIdSrc + } + return 0 +} + +func (m *CMsgClientP2PConnectionFailInfo) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientP2PConnectionFailInfo) GetEp2PSessionError() uint32 { + if m != nil && m.Ep2PSessionError != nil { + return *m.Ep2PSessionError + } + return 0 +} + +type CMsgClientGetAppOwnershipTicket struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAppOwnershipTicket) Reset() { *m = CMsgClientGetAppOwnershipTicket{} } +func (m *CMsgClientGetAppOwnershipTicket) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetAppOwnershipTicket) ProtoMessage() {} +func (*CMsgClientGetAppOwnershipTicket) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{14} +} + +func (m *CMsgClientGetAppOwnershipTicket) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientGetAppOwnershipTicketResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + Ticket []byte `protobuf:"bytes,3,opt,name=ticket" json:"ticket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAppOwnershipTicketResponse) Reset() { + *m = CMsgClientGetAppOwnershipTicketResponse{} +} +func (m *CMsgClientGetAppOwnershipTicketResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetAppOwnershipTicketResponse) ProtoMessage() {} +func (*CMsgClientGetAppOwnershipTicketResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{15} +} + +const Default_CMsgClientGetAppOwnershipTicketResponse_Eresult uint32 = 2 + +func (m *CMsgClientGetAppOwnershipTicketResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientGetAppOwnershipTicketResponse_Eresult +} + +func (m *CMsgClientGetAppOwnershipTicketResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientGetAppOwnershipTicketResponse) GetTicket() []byte { + if m != nil { + return m.Ticket + } + return nil +} + +type CMsgClientSessionToken struct { + Token *uint64 `protobuf:"varint,1,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSessionToken) Reset() { *m = CMsgClientSessionToken{} } +func (m *CMsgClientSessionToken) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSessionToken) ProtoMessage() {} +func (*CMsgClientSessionToken) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{16} } + +func (m *CMsgClientSessionToken) GetToken() uint64 { + if m != nil && m.Token != nil { + return *m.Token + } + return 0 +} + +type CMsgClientGameConnectTokens struct { + MaxTokensToKeep *uint32 `protobuf:"varint,1,opt,name=max_tokens_to_keep,def=10" json:"max_tokens_to_keep,omitempty"` + Tokens [][]byte `protobuf:"bytes,2,rep,name=tokens" json:"tokens,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGameConnectTokens) Reset() { *m = CMsgClientGameConnectTokens{} } +func (m *CMsgClientGameConnectTokens) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGameConnectTokens) ProtoMessage() {} +func (*CMsgClientGameConnectTokens) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{17} } + +const Default_CMsgClientGameConnectTokens_MaxTokensToKeep uint32 = 10 + +func (m *CMsgClientGameConnectTokens) GetMaxTokensToKeep() uint32 { + if m != nil && m.MaxTokensToKeep != nil { + return *m.MaxTokensToKeep + } + return Default_CMsgClientGameConnectTokens_MaxTokensToKeep +} + +func (m *CMsgClientGameConnectTokens) GetTokens() [][]byte { + if m != nil { + return m.Tokens + } + return nil +} + +type CMsgGSServerType struct { + AppIdServed *uint32 `protobuf:"varint,1,opt,name=app_id_served" json:"app_id_served,omitempty"` + Flags *uint32 `protobuf:"varint,2,opt,name=flags" json:"flags,omitempty"` + GameIpAddress *uint32 `protobuf:"varint,3,opt,name=game_ip_address" json:"game_ip_address,omitempty"` + GamePort *uint32 `protobuf:"varint,4,opt,name=game_port" json:"game_port,omitempty"` + GameDir *string `protobuf:"bytes,5,opt,name=game_dir" json:"game_dir,omitempty"` + GameVersion *string `protobuf:"bytes,6,opt,name=game_version" json:"game_version,omitempty"` + GameQueryPort *uint32 `protobuf:"varint,7,opt,name=game_query_port" json:"game_query_port,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSServerType) Reset() { *m = CMsgGSServerType{} } +func (m *CMsgGSServerType) String() string { return proto.CompactTextString(m) } +func (*CMsgGSServerType) ProtoMessage() {} +func (*CMsgGSServerType) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{18} } + +func (m *CMsgGSServerType) GetAppIdServed() uint32 { + if m != nil && m.AppIdServed != nil { + return *m.AppIdServed + } + return 0 +} + +func (m *CMsgGSServerType) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *CMsgGSServerType) GetGameIpAddress() uint32 { + if m != nil && m.GameIpAddress != nil { + return *m.GameIpAddress + } + return 0 +} + +func (m *CMsgGSServerType) GetGamePort() uint32 { + if m != nil && m.GamePort != nil { + return *m.GamePort + } + return 0 +} + +func (m *CMsgGSServerType) GetGameDir() string { + if m != nil && m.GameDir != nil { + return *m.GameDir + } + return "" +} + +func (m *CMsgGSServerType) GetGameVersion() string { + if m != nil && m.GameVersion != nil { + return *m.GameVersion + } + return "" +} + +func (m *CMsgGSServerType) GetGameQueryPort() uint32 { + if m != nil && m.GameQueryPort != nil { + return *m.GameQueryPort + } + return 0 +} + +type CMsgGSStatusReply struct { + IsSecure *bool `protobuf:"varint,1,opt,name=is_secure" json:"is_secure,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSStatusReply) Reset() { *m = CMsgGSStatusReply{} } +func (m *CMsgGSStatusReply) String() string { return proto.CompactTextString(m) } +func (*CMsgGSStatusReply) ProtoMessage() {} +func (*CMsgGSStatusReply) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{19} } + +func (m *CMsgGSStatusReply) GetIsSecure() bool { + if m != nil && m.IsSecure != nil { + return *m.IsSecure + } + return false +} + +type CMsgGSPlayerList struct { + Players []*CMsgGSPlayerList_Player `protobuf:"bytes,1,rep,name=players" json:"players,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSPlayerList) Reset() { *m = CMsgGSPlayerList{} } +func (m *CMsgGSPlayerList) String() string { return proto.CompactTextString(m) } +func (*CMsgGSPlayerList) ProtoMessage() {} +func (*CMsgGSPlayerList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{20} } + +func (m *CMsgGSPlayerList) GetPlayers() []*CMsgGSPlayerList_Player { + if m != nil { + return m.Players + } + return nil +} + +type CMsgGSPlayerList_Player struct { + SteamId *uint64 `protobuf:"varint,1,opt,name=steam_id" json:"steam_id,omitempty"` + PublicIp *uint32 `protobuf:"varint,2,opt,name=public_ip" json:"public_ip,omitempty"` + Token []byte `protobuf:"bytes,3,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSPlayerList_Player) Reset() { *m = CMsgGSPlayerList_Player{} } +func (m *CMsgGSPlayerList_Player) String() string { return proto.CompactTextString(m) } +func (*CMsgGSPlayerList_Player) ProtoMessage() {} +func (*CMsgGSPlayerList_Player) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{20, 0} } + +func (m *CMsgGSPlayerList_Player) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgGSPlayerList_Player) GetPublicIp() uint32 { + if m != nil && m.PublicIp != nil { + return *m.PublicIp + } + return 0 +} + +func (m *CMsgGSPlayerList_Player) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +type CMsgGSUserPlaying struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + PublicIp *uint32 `protobuf:"varint,2,opt,name=public_ip" json:"public_ip,omitempty"` + Token []byte `protobuf:"bytes,3,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSUserPlaying) Reset() { *m = CMsgGSUserPlaying{} } +func (m *CMsgGSUserPlaying) String() string { return proto.CompactTextString(m) } +func (*CMsgGSUserPlaying) ProtoMessage() {} +func (*CMsgGSUserPlaying) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{21} } + +func (m *CMsgGSUserPlaying) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgGSUserPlaying) GetPublicIp() uint32 { + if m != nil && m.PublicIp != nil { + return *m.PublicIp + } + return 0 +} + +func (m *CMsgGSUserPlaying) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +type CMsgGSDisconnectNotice struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSDisconnectNotice) Reset() { *m = CMsgGSDisconnectNotice{} } +func (m *CMsgGSDisconnectNotice) String() string { return proto.CompactTextString(m) } +func (*CMsgGSDisconnectNotice) ProtoMessage() {} +func (*CMsgGSDisconnectNotice) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{22} } + +func (m *CMsgGSDisconnectNotice) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CMsgClientGamesPlayed struct { + GamesPlayed []*CMsgClientGamesPlayed_GamePlayed `protobuf:"bytes,1,rep,name=games_played" json:"games_played,omitempty"` + ClientOsType *uint32 `protobuf:"varint,2,opt,name=client_os_type" json:"client_os_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGamesPlayed) Reset() { *m = CMsgClientGamesPlayed{} } +func (m *CMsgClientGamesPlayed) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGamesPlayed) ProtoMessage() {} +func (*CMsgClientGamesPlayed) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{23} } + +func (m *CMsgClientGamesPlayed) GetGamesPlayed() []*CMsgClientGamesPlayed_GamePlayed { + if m != nil { + return m.GamesPlayed + } + return nil +} + +func (m *CMsgClientGamesPlayed) GetClientOsType() uint32 { + if m != nil && m.ClientOsType != nil { + return *m.ClientOsType + } + return 0 +} + +type CMsgClientGamesPlayed_GamePlayed struct { + SteamIdGs *uint64 `protobuf:"varint,1,opt,name=steam_id_gs" json:"steam_id_gs,omitempty"` + GameId *uint64 `protobuf:"fixed64,2,opt,name=game_id" json:"game_id,omitempty"` + GameIpAddress *uint32 `protobuf:"varint,3,opt,name=game_ip_address" json:"game_ip_address,omitempty"` + GamePort *uint32 `protobuf:"varint,4,opt,name=game_port" json:"game_port,omitempty"` + IsSecure *bool `protobuf:"varint,5,opt,name=is_secure" json:"is_secure,omitempty"` + Token []byte `protobuf:"bytes,6,opt,name=token" json:"token,omitempty"` + GameExtraInfo *string `protobuf:"bytes,7,opt,name=game_extra_info" json:"game_extra_info,omitempty"` + GameDataBlob []byte `protobuf:"bytes,8,opt,name=game_data_blob" json:"game_data_blob,omitempty"` + ProcessId *uint32 `protobuf:"varint,9,opt,name=process_id" json:"process_id,omitempty"` + StreamingProviderId *uint32 `protobuf:"varint,10,opt,name=streaming_provider_id" json:"streaming_provider_id,omitempty"` + GameFlags *uint32 `protobuf:"varint,11,opt,name=game_flags" json:"game_flags,omitempty"` + OwnerId *uint32 `protobuf:"varint,12,opt,name=owner_id" json:"owner_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGamesPlayed_GamePlayed) Reset() { *m = CMsgClientGamesPlayed_GamePlayed{} } +func (m *CMsgClientGamesPlayed_GamePlayed) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGamesPlayed_GamePlayed) ProtoMessage() {} +func (*CMsgClientGamesPlayed_GamePlayed) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{23, 0} +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetSteamIdGs() uint64 { + if m != nil && m.SteamIdGs != nil { + return *m.SteamIdGs + } + return 0 +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetGameIpAddress() uint32 { + if m != nil && m.GameIpAddress != nil { + return *m.GameIpAddress + } + return 0 +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetGamePort() uint32 { + if m != nil && m.GamePort != nil { + return *m.GamePort + } + return 0 +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetIsSecure() bool { + if m != nil && m.IsSecure != nil { + return *m.IsSecure + } + return false +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetGameExtraInfo() string { + if m != nil && m.GameExtraInfo != nil { + return *m.GameExtraInfo + } + return "" +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetGameDataBlob() []byte { + if m != nil { + return m.GameDataBlob + } + return nil +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetProcessId() uint32 { + if m != nil && m.ProcessId != nil { + return *m.ProcessId + } + return 0 +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetStreamingProviderId() uint32 { + if m != nil && m.StreamingProviderId != nil { + return *m.StreamingProviderId + } + return 0 +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetGameFlags() uint32 { + if m != nil && m.GameFlags != nil { + return *m.GameFlags + } + return 0 +} + +func (m *CMsgClientGamesPlayed_GamePlayed) GetOwnerId() uint32 { + if m != nil && m.OwnerId != nil { + return *m.OwnerId + } + return 0 +} + +type CMsgGSApprove struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + OwnerSteamId *uint64 `protobuf:"fixed64,2,opt,name=owner_steam_id" json:"owner_steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSApprove) Reset() { *m = CMsgGSApprove{} } +func (m *CMsgGSApprove) String() string { return proto.CompactTextString(m) } +func (*CMsgGSApprove) ProtoMessage() {} +func (*CMsgGSApprove) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{24} } + +func (m *CMsgGSApprove) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgGSApprove) GetOwnerSteamId() uint64 { + if m != nil && m.OwnerSteamId != nil { + return *m.OwnerSteamId + } + return 0 +} + +type CMsgGSDeny struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + EdenyReason *int32 `protobuf:"varint,2,opt,name=edeny_reason" json:"edeny_reason,omitempty"` + DenyString *string `protobuf:"bytes,3,opt,name=deny_string" json:"deny_string,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSDeny) Reset() { *m = CMsgGSDeny{} } +func (m *CMsgGSDeny) String() string { return proto.CompactTextString(m) } +func (*CMsgGSDeny) ProtoMessage() {} +func (*CMsgGSDeny) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{25} } + +func (m *CMsgGSDeny) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgGSDeny) GetEdenyReason() int32 { + if m != nil && m.EdenyReason != nil { + return *m.EdenyReason + } + return 0 +} + +func (m *CMsgGSDeny) GetDenyString() string { + if m != nil && m.DenyString != nil { + return *m.DenyString + } + return "" +} + +type CMsgGSKick struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + EdenyReason *int32 `protobuf:"varint,2,opt,name=edeny_reason" json:"edeny_reason,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSKick) Reset() { *m = CMsgGSKick{} } +func (m *CMsgGSKick) String() string { return proto.CompactTextString(m) } +func (*CMsgGSKick) ProtoMessage() {} +func (*CMsgGSKick) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{26} } + +func (m *CMsgGSKick) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgGSKick) GetEdenyReason() int32 { + if m != nil && m.EdenyReason != nil { + return *m.EdenyReason + } + return 0 +} + +type CMsgClientAuthList struct { + TokensLeft *uint32 `protobuf:"varint,1,opt,name=tokens_left" json:"tokens_left,omitempty"` + LastRequestSeq *uint32 `protobuf:"varint,2,opt,name=last_request_seq" json:"last_request_seq,omitempty"` + LastRequestSeqFromServer *uint32 `protobuf:"varint,3,opt,name=last_request_seq_from_server" json:"last_request_seq_from_server,omitempty"` + Tickets []*CMsgAuthTicket `protobuf:"bytes,4,rep,name=tickets" json:"tickets,omitempty"` + AppIds []uint32 `protobuf:"varint,5,rep,name=app_ids" json:"app_ids,omitempty"` + MessageSequence *uint32 `protobuf:"varint,6,opt,name=message_sequence" json:"message_sequence,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAuthList) Reset() { *m = CMsgClientAuthList{} } +func (m *CMsgClientAuthList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAuthList) ProtoMessage() {} +func (*CMsgClientAuthList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{27} } + +func (m *CMsgClientAuthList) GetTokensLeft() uint32 { + if m != nil && m.TokensLeft != nil { + return *m.TokensLeft + } + return 0 +} + +func (m *CMsgClientAuthList) GetLastRequestSeq() uint32 { + if m != nil && m.LastRequestSeq != nil { + return *m.LastRequestSeq + } + return 0 +} + +func (m *CMsgClientAuthList) GetLastRequestSeqFromServer() uint32 { + if m != nil && m.LastRequestSeqFromServer != nil { + return *m.LastRequestSeqFromServer + } + return 0 +} + +func (m *CMsgClientAuthList) GetTickets() []*CMsgAuthTicket { + if m != nil { + return m.Tickets + } + return nil +} + +func (m *CMsgClientAuthList) GetAppIds() []uint32 { + if m != nil { + return m.AppIds + } + return nil +} + +func (m *CMsgClientAuthList) GetMessageSequence() uint32 { + if m != nil && m.MessageSequence != nil { + return *m.MessageSequence + } + return 0 +} + +type CMsgClientAuthListAck struct { + TicketCrc []uint32 `protobuf:"varint,1,rep,name=ticket_crc" json:"ticket_crc,omitempty"` + AppIds []uint32 `protobuf:"varint,2,rep,name=app_ids" json:"app_ids,omitempty"` + MessageSequence *uint32 `protobuf:"varint,3,opt,name=message_sequence" json:"message_sequence,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAuthListAck) Reset() { *m = CMsgClientAuthListAck{} } +func (m *CMsgClientAuthListAck) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAuthListAck) ProtoMessage() {} +func (*CMsgClientAuthListAck) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{28} } + +func (m *CMsgClientAuthListAck) GetTicketCrc() []uint32 { + if m != nil { + return m.TicketCrc + } + return nil +} + +func (m *CMsgClientAuthListAck) GetAppIds() []uint32 { + if m != nil { + return m.AppIds + } + return nil +} + +func (m *CMsgClientAuthListAck) GetMessageSequence() uint32 { + if m != nil && m.MessageSequence != nil { + return *m.MessageSequence + } + return 0 +} + +type CMsgClientFriendsList struct { + Bincremental *bool `protobuf:"varint,1,opt,name=bincremental" json:"bincremental,omitempty"` + Friends []*CMsgClientFriendsList_Friend `protobuf:"bytes,2,rep,name=friends" json:"friends,omitempty"` + MaxFriendCount *uint32 `protobuf:"varint,3,opt,name=max_friend_count" json:"max_friend_count,omitempty"` + ActiveFriendCount *uint32 `protobuf:"varint,4,opt,name=active_friend_count" json:"active_friend_count,omitempty"` + FriendsLimitHit *bool `protobuf:"varint,5,opt,name=friends_limit_hit" json:"friends_limit_hit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendsList) Reset() { *m = CMsgClientFriendsList{} } +func (m *CMsgClientFriendsList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendsList) ProtoMessage() {} +func (*CMsgClientFriendsList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{29} } + +func (m *CMsgClientFriendsList) GetBincremental() bool { + if m != nil && m.Bincremental != nil { + return *m.Bincremental + } + return false +} + +func (m *CMsgClientFriendsList) GetFriends() []*CMsgClientFriendsList_Friend { + if m != nil { + return m.Friends + } + return nil +} + +func (m *CMsgClientFriendsList) GetMaxFriendCount() uint32 { + if m != nil && m.MaxFriendCount != nil { + return *m.MaxFriendCount + } + return 0 +} + +func (m *CMsgClientFriendsList) GetActiveFriendCount() uint32 { + if m != nil && m.ActiveFriendCount != nil { + return *m.ActiveFriendCount + } + return 0 +} + +func (m *CMsgClientFriendsList) GetFriendsLimitHit() bool { + if m != nil && m.FriendsLimitHit != nil { + return *m.FriendsLimitHit + } + return false +} + +type CMsgClientFriendsList_Friend struct { + Ulfriendid *uint64 `protobuf:"fixed64,1,opt,name=ulfriendid" json:"ulfriendid,omitempty"` + Efriendrelationship *uint32 `protobuf:"varint,2,opt,name=efriendrelationship" json:"efriendrelationship,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendsList_Friend) Reset() { *m = CMsgClientFriendsList_Friend{} } +func (m *CMsgClientFriendsList_Friend) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendsList_Friend) ProtoMessage() {} +func (*CMsgClientFriendsList_Friend) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{29, 0} +} + +func (m *CMsgClientFriendsList_Friend) GetUlfriendid() uint64 { + if m != nil && m.Ulfriendid != nil { + return *m.Ulfriendid + } + return 0 +} + +func (m *CMsgClientFriendsList_Friend) GetEfriendrelationship() uint32 { + if m != nil && m.Efriendrelationship != nil { + return *m.Efriendrelationship + } + return 0 +} + +type CMsgClientFriendsGroupsList struct { + Bremoval *bool `protobuf:"varint,1,opt,name=bremoval" json:"bremoval,omitempty"` + Bincremental *bool `protobuf:"varint,2,opt,name=bincremental" json:"bincremental,omitempty"` + FriendGroups []*CMsgClientFriendsGroupsList_FriendGroup `protobuf:"bytes,3,rep,name=friendGroups" json:"friendGroups,omitempty"` + Memberships []*CMsgClientFriendsGroupsList_FriendGroupsMembership `protobuf:"bytes,4,rep,name=memberships" json:"memberships,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendsGroupsList) Reset() { *m = CMsgClientFriendsGroupsList{} } +func (m *CMsgClientFriendsGroupsList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendsGroupsList) ProtoMessage() {} +func (*CMsgClientFriendsGroupsList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{30} } + +func (m *CMsgClientFriendsGroupsList) GetBremoval() bool { + if m != nil && m.Bremoval != nil { + return *m.Bremoval + } + return false +} + +func (m *CMsgClientFriendsGroupsList) GetBincremental() bool { + if m != nil && m.Bincremental != nil { + return *m.Bincremental + } + return false +} + +func (m *CMsgClientFriendsGroupsList) GetFriendGroups() []*CMsgClientFriendsGroupsList_FriendGroup { + if m != nil { + return m.FriendGroups + } + return nil +} + +func (m *CMsgClientFriendsGroupsList) GetMemberships() []*CMsgClientFriendsGroupsList_FriendGroupsMembership { + if m != nil { + return m.Memberships + } + return nil +} + +type CMsgClientFriendsGroupsList_FriendGroup struct { + NGroupID *int32 `protobuf:"varint,1,opt,name=nGroupID" json:"nGroupID,omitempty"` + StrGroupName *string `protobuf:"bytes,2,opt,name=strGroupName" json:"strGroupName,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendsGroupsList_FriendGroup) Reset() { + *m = CMsgClientFriendsGroupsList_FriendGroup{} +} +func (m *CMsgClientFriendsGroupsList_FriendGroup) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendsGroupsList_FriendGroup) ProtoMessage() {} +func (*CMsgClientFriendsGroupsList_FriendGroup) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{30, 0} +} + +func (m *CMsgClientFriendsGroupsList_FriendGroup) GetNGroupID() int32 { + if m != nil && m.NGroupID != nil { + return *m.NGroupID + } + return 0 +} + +func (m *CMsgClientFriendsGroupsList_FriendGroup) GetStrGroupName() string { + if m != nil && m.StrGroupName != nil { + return *m.StrGroupName + } + return "" +} + +type CMsgClientFriendsGroupsList_FriendGroupsMembership struct { + UlSteamID *uint64 `protobuf:"fixed64,1,opt,name=ulSteamID" json:"ulSteamID,omitempty"` + NGroupID *int32 `protobuf:"varint,2,opt,name=nGroupID" json:"nGroupID,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendsGroupsList_FriendGroupsMembership) Reset() { + *m = CMsgClientFriendsGroupsList_FriendGroupsMembership{} +} +func (m *CMsgClientFriendsGroupsList_FriendGroupsMembership) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientFriendsGroupsList_FriendGroupsMembership) ProtoMessage() {} +func (*CMsgClientFriendsGroupsList_FriendGroupsMembership) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{30, 1} +} + +func (m *CMsgClientFriendsGroupsList_FriendGroupsMembership) GetUlSteamID() uint64 { + if m != nil && m.UlSteamID != nil { + return *m.UlSteamID + } + return 0 +} + +func (m *CMsgClientFriendsGroupsList_FriendGroupsMembership) GetNGroupID() int32 { + if m != nil && m.NGroupID != nil { + return *m.NGroupID + } + return 0 +} + +type CMsgClientPlayerNicknameList struct { + Removal *bool `protobuf:"varint,1,opt,name=removal" json:"removal,omitempty"` + Incremental *bool `protobuf:"varint,2,opt,name=incremental" json:"incremental,omitempty"` + Nicknames []*CMsgClientPlayerNicknameList_PlayerNickname `protobuf:"bytes,3,rep,name=nicknames" json:"nicknames,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPlayerNicknameList) Reset() { *m = CMsgClientPlayerNicknameList{} } +func (m *CMsgClientPlayerNicknameList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPlayerNicknameList) ProtoMessage() {} +func (*CMsgClientPlayerNicknameList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{31} } + +func (m *CMsgClientPlayerNicknameList) GetRemoval() bool { + if m != nil && m.Removal != nil { + return *m.Removal + } + return false +} + +func (m *CMsgClientPlayerNicknameList) GetIncremental() bool { + if m != nil && m.Incremental != nil { + return *m.Incremental + } + return false +} + +func (m *CMsgClientPlayerNicknameList) GetNicknames() []*CMsgClientPlayerNicknameList_PlayerNickname { + if m != nil { + return m.Nicknames + } + return nil +} + +type CMsgClientPlayerNicknameList_PlayerNickname struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Nickname *string `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPlayerNicknameList_PlayerNickname) Reset() { + *m = CMsgClientPlayerNicknameList_PlayerNickname{} +} +func (m *CMsgClientPlayerNicknameList_PlayerNickname) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientPlayerNicknameList_PlayerNickname) ProtoMessage() {} +func (*CMsgClientPlayerNicknameList_PlayerNickname) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{31, 0} +} + +func (m *CMsgClientPlayerNicknameList_PlayerNickname) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgClientPlayerNicknameList_PlayerNickname) GetNickname() string { + if m != nil && m.Nickname != nil { + return *m.Nickname + } + return "" +} + +type CMsgClientSetPlayerNickname struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Nickname *string `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSetPlayerNickname) Reset() { *m = CMsgClientSetPlayerNickname{} } +func (m *CMsgClientSetPlayerNickname) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSetPlayerNickname) ProtoMessage() {} +func (*CMsgClientSetPlayerNickname) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{32} } + +func (m *CMsgClientSetPlayerNickname) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgClientSetPlayerNickname) GetNickname() string { + if m != nil && m.Nickname != nil { + return *m.Nickname + } + return "" +} + +type CMsgClientSetPlayerNicknameResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSetPlayerNicknameResponse) Reset() { *m = CMsgClientSetPlayerNicknameResponse{} } +func (m *CMsgClientSetPlayerNicknameResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSetPlayerNicknameResponse) ProtoMessage() {} +func (*CMsgClientSetPlayerNicknameResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{33} +} + +func (m *CMsgClientSetPlayerNicknameResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgClientLicenseList struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Licenses []*CMsgClientLicenseList_License `protobuf:"bytes,2,rep,name=licenses" json:"licenses,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLicenseList) Reset() { *m = CMsgClientLicenseList{} } +func (m *CMsgClientLicenseList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLicenseList) ProtoMessage() {} +func (*CMsgClientLicenseList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{34} } + +const Default_CMsgClientLicenseList_Eresult int32 = 2 + +func (m *CMsgClientLicenseList) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientLicenseList_Eresult +} + +func (m *CMsgClientLicenseList) GetLicenses() []*CMsgClientLicenseList_License { + if m != nil { + return m.Licenses + } + return nil +} + +type CMsgClientLicenseList_License struct { + PackageId *uint32 `protobuf:"varint,1,opt,name=package_id" json:"package_id,omitempty"` + TimeCreated *uint32 `protobuf:"fixed32,2,opt,name=time_created" json:"time_created,omitempty"` + TimeNextProcess *uint32 `protobuf:"fixed32,3,opt,name=time_next_process" json:"time_next_process,omitempty"` + MinuteLimit *int32 `protobuf:"varint,4,opt,name=minute_limit" json:"minute_limit,omitempty"` + MinutesUsed *int32 `protobuf:"varint,5,opt,name=minutes_used" json:"minutes_used,omitempty"` + PaymentMethod *uint32 `protobuf:"varint,6,opt,name=payment_method" json:"payment_method,omitempty"` + Flags *uint32 `protobuf:"varint,7,opt,name=flags" json:"flags,omitempty"` + PurchaseCountryCode *string `protobuf:"bytes,8,opt,name=purchase_country_code" json:"purchase_country_code,omitempty"` + LicenseType *uint32 `protobuf:"varint,9,opt,name=license_type" json:"license_type,omitempty"` + TerritoryCode *int32 `protobuf:"varint,10,opt,name=territory_code" json:"territory_code,omitempty"` + ChangeNumber *int32 `protobuf:"varint,11,opt,name=change_number" json:"change_number,omitempty"` + OwnerId *uint32 `protobuf:"varint,12,opt,name=owner_id" json:"owner_id,omitempty"` + InitialPeriod *uint32 `protobuf:"varint,13,opt,name=initial_period" json:"initial_period,omitempty"` + InitialTimeUnit *uint32 `protobuf:"varint,14,opt,name=initial_time_unit" json:"initial_time_unit,omitempty"` + RenewalPeriod *uint32 `protobuf:"varint,15,opt,name=renewal_period" json:"renewal_period,omitempty"` + RenewalTimeUnit *uint32 `protobuf:"varint,16,opt,name=renewal_time_unit" json:"renewal_time_unit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLicenseList_License) Reset() { *m = CMsgClientLicenseList_License{} } +func (m *CMsgClientLicenseList_License) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLicenseList_License) ProtoMessage() {} +func (*CMsgClientLicenseList_License) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{34, 0} +} + +func (m *CMsgClientLicenseList_License) GetPackageId() uint32 { + if m != nil && m.PackageId != nil { + return *m.PackageId + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetTimeNextProcess() uint32 { + if m != nil && m.TimeNextProcess != nil { + return *m.TimeNextProcess + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetMinuteLimit() int32 { + if m != nil && m.MinuteLimit != nil { + return *m.MinuteLimit + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetMinutesUsed() int32 { + if m != nil && m.MinutesUsed != nil { + return *m.MinutesUsed + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetPaymentMethod() uint32 { + if m != nil && m.PaymentMethod != nil { + return *m.PaymentMethod + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetPurchaseCountryCode() string { + if m != nil && m.PurchaseCountryCode != nil { + return *m.PurchaseCountryCode + } + return "" +} + +func (m *CMsgClientLicenseList_License) GetLicenseType() uint32 { + if m != nil && m.LicenseType != nil { + return *m.LicenseType + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetTerritoryCode() int32 { + if m != nil && m.TerritoryCode != nil { + return *m.TerritoryCode + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetChangeNumber() int32 { + if m != nil && m.ChangeNumber != nil { + return *m.ChangeNumber + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetOwnerId() uint32 { + if m != nil && m.OwnerId != nil { + return *m.OwnerId + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetInitialPeriod() uint32 { + if m != nil && m.InitialPeriod != nil { + return *m.InitialPeriod + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetInitialTimeUnit() uint32 { + if m != nil && m.InitialTimeUnit != nil { + return *m.InitialTimeUnit + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetRenewalPeriod() uint32 { + if m != nil && m.RenewalPeriod != nil { + return *m.RenewalPeriod + } + return 0 +} + +func (m *CMsgClientLicenseList_License) GetRenewalTimeUnit() uint32 { + if m != nil && m.RenewalTimeUnit != nil { + return *m.RenewalTimeUnit + } + return 0 +} + +type CMsgClientLBSSetScore struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + LeaderboardId *int32 `protobuf:"varint,2,opt,name=leaderboard_id" json:"leaderboard_id,omitempty"` + Score *int32 `protobuf:"varint,3,opt,name=score" json:"score,omitempty"` + Details []byte `protobuf:"bytes,4,opt,name=details" json:"details,omitempty"` + UploadScoreMethod *int32 `protobuf:"varint,5,opt,name=upload_score_method" json:"upload_score_method,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSSetScore) Reset() { *m = CMsgClientLBSSetScore{} } +func (m *CMsgClientLBSSetScore) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSSetScore) ProtoMessage() {} +func (*CMsgClientLBSSetScore) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{35} } + +func (m *CMsgClientLBSSetScore) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientLBSSetScore) GetLeaderboardId() int32 { + if m != nil && m.LeaderboardId != nil { + return *m.LeaderboardId + } + return 0 +} + +func (m *CMsgClientLBSSetScore) GetScore() int32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *CMsgClientLBSSetScore) GetDetails() []byte { + if m != nil { + return m.Details + } + return nil +} + +func (m *CMsgClientLBSSetScore) GetUploadScoreMethod() int32 { + if m != nil && m.UploadScoreMethod != nil { + return *m.UploadScoreMethod + } + return 0 +} + +type CMsgClientLBSSetScoreResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + LeaderboardEntryCount *int32 `protobuf:"varint,2,opt,name=leaderboard_entry_count" json:"leaderboard_entry_count,omitempty"` + ScoreChanged *bool `protobuf:"varint,3,opt,name=score_changed" json:"score_changed,omitempty"` + GlobalRankPrevious *int32 `protobuf:"varint,4,opt,name=global_rank_previous" json:"global_rank_previous,omitempty"` + GlobalRankNew *int32 `protobuf:"varint,5,opt,name=global_rank_new" json:"global_rank_new,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSSetScoreResponse) Reset() { *m = CMsgClientLBSSetScoreResponse{} } +func (m *CMsgClientLBSSetScoreResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSSetScoreResponse) ProtoMessage() {} +func (*CMsgClientLBSSetScoreResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{36} } + +const Default_CMsgClientLBSSetScoreResponse_Eresult int32 = 2 + +func (m *CMsgClientLBSSetScoreResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientLBSSetScoreResponse_Eresult +} + +func (m *CMsgClientLBSSetScoreResponse) GetLeaderboardEntryCount() int32 { + if m != nil && m.LeaderboardEntryCount != nil { + return *m.LeaderboardEntryCount + } + return 0 +} + +func (m *CMsgClientLBSSetScoreResponse) GetScoreChanged() bool { + if m != nil && m.ScoreChanged != nil { + return *m.ScoreChanged + } + return false +} + +func (m *CMsgClientLBSSetScoreResponse) GetGlobalRankPrevious() int32 { + if m != nil && m.GlobalRankPrevious != nil { + return *m.GlobalRankPrevious + } + return 0 +} + +func (m *CMsgClientLBSSetScoreResponse) GetGlobalRankNew() int32 { + if m != nil && m.GlobalRankNew != nil { + return *m.GlobalRankNew + } + return 0 +} + +type CMsgClientLBSSetUGC struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + LeaderboardId *int32 `protobuf:"varint,2,opt,name=leaderboard_id" json:"leaderboard_id,omitempty"` + UgcId *uint64 `protobuf:"fixed64,3,opt,name=ugc_id" json:"ugc_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSSetUGC) Reset() { *m = CMsgClientLBSSetUGC{} } +func (m *CMsgClientLBSSetUGC) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSSetUGC) ProtoMessage() {} +func (*CMsgClientLBSSetUGC) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{37} } + +func (m *CMsgClientLBSSetUGC) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientLBSSetUGC) GetLeaderboardId() int32 { + if m != nil && m.LeaderboardId != nil { + return *m.LeaderboardId + } + return 0 +} + +func (m *CMsgClientLBSSetUGC) GetUgcId() uint64 { + if m != nil && m.UgcId != nil { + return *m.UgcId + } + return 0 +} + +type CMsgClientLBSSetUGCResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSSetUGCResponse) Reset() { *m = CMsgClientLBSSetUGCResponse{} } +func (m *CMsgClientLBSSetUGCResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSSetUGCResponse) ProtoMessage() {} +func (*CMsgClientLBSSetUGCResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{38} } + +const Default_CMsgClientLBSSetUGCResponse_Eresult int32 = 2 + +func (m *CMsgClientLBSSetUGCResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientLBSSetUGCResponse_Eresult +} + +type CMsgClientLBSFindOrCreateLB struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + LeaderboardSortMethod *int32 `protobuf:"varint,2,opt,name=leaderboard_sort_method" json:"leaderboard_sort_method,omitempty"` + LeaderboardDisplayType *int32 `protobuf:"varint,3,opt,name=leaderboard_display_type" json:"leaderboard_display_type,omitempty"` + CreateIfNotFound *bool `protobuf:"varint,4,opt,name=create_if_not_found" json:"create_if_not_found,omitempty"` + LeaderboardName *string `protobuf:"bytes,5,opt,name=leaderboard_name" json:"leaderboard_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSFindOrCreateLB) Reset() { *m = CMsgClientLBSFindOrCreateLB{} } +func (m *CMsgClientLBSFindOrCreateLB) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSFindOrCreateLB) ProtoMessage() {} +func (*CMsgClientLBSFindOrCreateLB) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{39} } + +func (m *CMsgClientLBSFindOrCreateLB) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientLBSFindOrCreateLB) GetLeaderboardSortMethod() int32 { + if m != nil && m.LeaderboardSortMethod != nil { + return *m.LeaderboardSortMethod + } + return 0 +} + +func (m *CMsgClientLBSFindOrCreateLB) GetLeaderboardDisplayType() int32 { + if m != nil && m.LeaderboardDisplayType != nil { + return *m.LeaderboardDisplayType + } + return 0 +} + +func (m *CMsgClientLBSFindOrCreateLB) GetCreateIfNotFound() bool { + if m != nil && m.CreateIfNotFound != nil { + return *m.CreateIfNotFound + } + return false +} + +func (m *CMsgClientLBSFindOrCreateLB) GetLeaderboardName() string { + if m != nil && m.LeaderboardName != nil { + return *m.LeaderboardName + } + return "" +} + +type CMsgClientLBSFindOrCreateLBResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + LeaderboardId *int32 `protobuf:"varint,2,opt,name=leaderboard_id" json:"leaderboard_id,omitempty"` + LeaderboardEntryCount *int32 `protobuf:"varint,3,opt,name=leaderboard_entry_count" json:"leaderboard_entry_count,omitempty"` + LeaderboardSortMethod *int32 `protobuf:"varint,4,opt,name=leaderboard_sort_method,def=0" json:"leaderboard_sort_method,omitempty"` + LeaderboardDisplayType *int32 `protobuf:"varint,5,opt,name=leaderboard_display_type,def=0" json:"leaderboard_display_type,omitempty"` + LeaderboardName *string `protobuf:"bytes,6,opt,name=leaderboard_name" json:"leaderboard_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSFindOrCreateLBResponse) Reset() { *m = CMsgClientLBSFindOrCreateLBResponse{} } +func (m *CMsgClientLBSFindOrCreateLBResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSFindOrCreateLBResponse) ProtoMessage() {} +func (*CMsgClientLBSFindOrCreateLBResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{40} +} + +const Default_CMsgClientLBSFindOrCreateLBResponse_Eresult int32 = 2 +const Default_CMsgClientLBSFindOrCreateLBResponse_LeaderboardSortMethod int32 = 0 +const Default_CMsgClientLBSFindOrCreateLBResponse_LeaderboardDisplayType int32 = 0 + +func (m *CMsgClientLBSFindOrCreateLBResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientLBSFindOrCreateLBResponse_Eresult +} + +func (m *CMsgClientLBSFindOrCreateLBResponse) GetLeaderboardId() int32 { + if m != nil && m.LeaderboardId != nil { + return *m.LeaderboardId + } + return 0 +} + +func (m *CMsgClientLBSFindOrCreateLBResponse) GetLeaderboardEntryCount() int32 { + if m != nil && m.LeaderboardEntryCount != nil { + return *m.LeaderboardEntryCount + } + return 0 +} + +func (m *CMsgClientLBSFindOrCreateLBResponse) GetLeaderboardSortMethod() int32 { + if m != nil && m.LeaderboardSortMethod != nil { + return *m.LeaderboardSortMethod + } + return Default_CMsgClientLBSFindOrCreateLBResponse_LeaderboardSortMethod +} + +func (m *CMsgClientLBSFindOrCreateLBResponse) GetLeaderboardDisplayType() int32 { + if m != nil && m.LeaderboardDisplayType != nil { + return *m.LeaderboardDisplayType + } + return Default_CMsgClientLBSFindOrCreateLBResponse_LeaderboardDisplayType +} + +func (m *CMsgClientLBSFindOrCreateLBResponse) GetLeaderboardName() string { + if m != nil && m.LeaderboardName != nil { + return *m.LeaderboardName + } + return "" +} + +type CMsgClientLBSGetLBEntries struct { + AppId *int32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + LeaderboardId *int32 `protobuf:"varint,2,opt,name=leaderboard_id" json:"leaderboard_id,omitempty"` + RangeStart *int32 `protobuf:"varint,3,opt,name=range_start" json:"range_start,omitempty"` + RangeEnd *int32 `protobuf:"varint,4,opt,name=range_end" json:"range_end,omitempty"` + LeaderboardDataRequest *int32 `protobuf:"varint,5,opt,name=leaderboard_data_request" json:"leaderboard_data_request,omitempty"` + Steamids []uint64 `protobuf:"fixed64,6,rep,name=steamids" json:"steamids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSGetLBEntries) Reset() { *m = CMsgClientLBSGetLBEntries{} } +func (m *CMsgClientLBSGetLBEntries) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSGetLBEntries) ProtoMessage() {} +func (*CMsgClientLBSGetLBEntries) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{41} } + +func (m *CMsgClientLBSGetLBEntries) GetAppId() int32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntries) GetLeaderboardId() int32 { + if m != nil && m.LeaderboardId != nil { + return *m.LeaderboardId + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntries) GetRangeStart() int32 { + if m != nil && m.RangeStart != nil { + return *m.RangeStart + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntries) GetRangeEnd() int32 { + if m != nil && m.RangeEnd != nil { + return *m.RangeEnd + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntries) GetLeaderboardDataRequest() int32 { + if m != nil && m.LeaderboardDataRequest != nil { + return *m.LeaderboardDataRequest + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntries) GetSteamids() []uint64 { + if m != nil { + return m.Steamids + } + return nil +} + +type CMsgClientLBSGetLBEntriesResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + LeaderboardEntryCount *int32 `protobuf:"varint,2,opt,name=leaderboard_entry_count" json:"leaderboard_entry_count,omitempty"` + Entries []*CMsgClientLBSGetLBEntriesResponse_Entry `protobuf:"bytes,3,rep,name=entries" json:"entries,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSGetLBEntriesResponse) Reset() { *m = CMsgClientLBSGetLBEntriesResponse{} } +func (m *CMsgClientLBSGetLBEntriesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSGetLBEntriesResponse) ProtoMessage() {} +func (*CMsgClientLBSGetLBEntriesResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{42} +} + +const Default_CMsgClientLBSGetLBEntriesResponse_Eresult int32 = 2 + +func (m *CMsgClientLBSGetLBEntriesResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientLBSGetLBEntriesResponse_Eresult +} + +func (m *CMsgClientLBSGetLBEntriesResponse) GetLeaderboardEntryCount() int32 { + if m != nil && m.LeaderboardEntryCount != nil { + return *m.LeaderboardEntryCount + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntriesResponse) GetEntries() []*CMsgClientLBSGetLBEntriesResponse_Entry { + if m != nil { + return m.Entries + } + return nil +} + +type CMsgClientLBSGetLBEntriesResponse_Entry struct { + SteamIdUser *uint64 `protobuf:"fixed64,1,opt,name=steam_id_user" json:"steam_id_user,omitempty"` + GlobalRank *int32 `protobuf:"varint,2,opt,name=global_rank" json:"global_rank,omitempty"` + Score *int32 `protobuf:"varint,3,opt,name=score" json:"score,omitempty"` + Details []byte `protobuf:"bytes,4,opt,name=details" json:"details,omitempty"` + UgcId *uint64 `protobuf:"fixed64,5,opt,name=ugc_id" json:"ugc_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientLBSGetLBEntriesResponse_Entry) Reset() { + *m = CMsgClientLBSGetLBEntriesResponse_Entry{} +} +func (m *CMsgClientLBSGetLBEntriesResponse_Entry) String() string { return proto.CompactTextString(m) } +func (*CMsgClientLBSGetLBEntriesResponse_Entry) ProtoMessage() {} +func (*CMsgClientLBSGetLBEntriesResponse_Entry) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{42, 0} +} + +func (m *CMsgClientLBSGetLBEntriesResponse_Entry) GetSteamIdUser() uint64 { + if m != nil && m.SteamIdUser != nil { + return *m.SteamIdUser + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntriesResponse_Entry) GetGlobalRank() int32 { + if m != nil && m.GlobalRank != nil { + return *m.GlobalRank + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntriesResponse_Entry) GetScore() int32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *CMsgClientLBSGetLBEntriesResponse_Entry) GetDetails() []byte { + if m != nil { + return m.Details + } + return nil +} + +func (m *CMsgClientLBSGetLBEntriesResponse_Entry) GetUgcId() uint64 { + if m != nil && m.UgcId != nil { + return *m.UgcId + } + return 0 +} + +type CMsgClientAccountInfo struct { + PersonaName *string `protobuf:"bytes,1,opt,name=persona_name" json:"persona_name,omitempty"` + IpCountry *string `protobuf:"bytes,2,opt,name=ip_country" json:"ip_country,omitempty"` + CountAuthedComputers *int32 `protobuf:"varint,5,opt,name=count_authed_computers" json:"count_authed_computers,omitempty"` + AccountFlags *uint32 `protobuf:"varint,7,opt,name=account_flags" json:"account_flags,omitempty"` + FacebookId *uint64 `protobuf:"varint,8,opt,name=facebook_id" json:"facebook_id,omitempty"` + FacebookName *string `protobuf:"bytes,9,opt,name=facebook_name" json:"facebook_name,omitempty"` + SteamguardNotifyNewmachines *bool `protobuf:"varint,14,opt,name=steamguard_notify_newmachines" json:"steamguard_notify_newmachines,omitempty"` + SteamguardMachineNameUserChosen *string `protobuf:"bytes,15,opt,name=steamguard_machine_name_user_chosen" json:"steamguard_machine_name_user_chosen,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAccountInfo) Reset() { *m = CMsgClientAccountInfo{} } +func (m *CMsgClientAccountInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAccountInfo) ProtoMessage() {} +func (*CMsgClientAccountInfo) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{43} } + +func (m *CMsgClientAccountInfo) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgClientAccountInfo) GetIpCountry() string { + if m != nil && m.IpCountry != nil { + return *m.IpCountry + } + return "" +} + +func (m *CMsgClientAccountInfo) GetCountAuthedComputers() int32 { + if m != nil && m.CountAuthedComputers != nil { + return *m.CountAuthedComputers + } + return 0 +} + +func (m *CMsgClientAccountInfo) GetAccountFlags() uint32 { + if m != nil && m.AccountFlags != nil { + return *m.AccountFlags + } + return 0 +} + +func (m *CMsgClientAccountInfo) GetFacebookId() uint64 { + if m != nil && m.FacebookId != nil { + return *m.FacebookId + } + return 0 +} + +func (m *CMsgClientAccountInfo) GetFacebookName() string { + if m != nil && m.FacebookName != nil { + return *m.FacebookName + } + return "" +} + +func (m *CMsgClientAccountInfo) GetSteamguardNotifyNewmachines() bool { + if m != nil && m.SteamguardNotifyNewmachines != nil { + return *m.SteamguardNotifyNewmachines + } + return false +} + +func (m *CMsgClientAccountInfo) GetSteamguardMachineNameUserChosen() string { + if m != nil && m.SteamguardMachineNameUserChosen != nil { + return *m.SteamguardMachineNameUserChosen + } + return "" +} + +type CMsgClientAppMinutesPlayedData struct { + MinutesPlayed []*CMsgClientAppMinutesPlayedData_AppMinutesPlayedData `protobuf:"bytes,1,rep,name=minutes_played" json:"minutes_played,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppMinutesPlayedData) Reset() { *m = CMsgClientAppMinutesPlayedData{} } +func (m *CMsgClientAppMinutesPlayedData) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppMinutesPlayedData) ProtoMessage() {} +func (*CMsgClientAppMinutesPlayedData) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{44} } + +func (m *CMsgClientAppMinutesPlayedData) GetMinutesPlayed() []*CMsgClientAppMinutesPlayedData_AppMinutesPlayedData { + if m != nil { + return m.MinutesPlayed + } + return nil +} + +type CMsgClientAppMinutesPlayedData_AppMinutesPlayedData struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + Forever *int32 `protobuf:"varint,2,opt,name=forever" json:"forever,omitempty"` + LastTwoWeeks *int32 `protobuf:"varint,3,opt,name=last_two_weeks" json:"last_two_weeks,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppMinutesPlayedData_AppMinutesPlayedData) Reset() { + *m = CMsgClientAppMinutesPlayedData_AppMinutesPlayedData{} +} +func (m *CMsgClientAppMinutesPlayedData_AppMinutesPlayedData) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientAppMinutesPlayedData_AppMinutesPlayedData) ProtoMessage() {} +func (*CMsgClientAppMinutesPlayedData_AppMinutesPlayedData) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{44, 0} +} + +func (m *CMsgClientAppMinutesPlayedData_AppMinutesPlayedData) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientAppMinutesPlayedData_AppMinutesPlayedData) GetForever() int32 { + if m != nil && m.Forever != nil { + return *m.Forever + } + return 0 +} + +func (m *CMsgClientAppMinutesPlayedData_AppMinutesPlayedData) GetLastTwoWeeks() int32 { + if m != nil && m.LastTwoWeeks != nil { + return *m.LastTwoWeeks + } + return 0 +} + +type CMsgClientIsLimitedAccount struct { + BisLimitedAccount *bool `protobuf:"varint,1,opt,name=bis_limited_account" json:"bis_limited_account,omitempty"` + BisCommunityBanned *bool `protobuf:"varint,2,opt,name=bis_community_banned" json:"bis_community_banned,omitempty"` + BisLockedAccount *bool `protobuf:"varint,3,opt,name=bis_locked_account" json:"bis_locked_account,omitempty"` + BisLimitedAccountAllowedToInviteFriends *bool `protobuf:"varint,4,opt,name=bis_limited_account_allowed_to_invite_friends" json:"bis_limited_account_allowed_to_invite_friends,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientIsLimitedAccount) Reset() { *m = CMsgClientIsLimitedAccount{} } +func (m *CMsgClientIsLimitedAccount) String() string { return proto.CompactTextString(m) } +func (*CMsgClientIsLimitedAccount) ProtoMessage() {} +func (*CMsgClientIsLimitedAccount) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{45} } + +func (m *CMsgClientIsLimitedAccount) GetBisLimitedAccount() bool { + if m != nil && m.BisLimitedAccount != nil { + return *m.BisLimitedAccount + } + return false +} + +func (m *CMsgClientIsLimitedAccount) GetBisCommunityBanned() bool { + if m != nil && m.BisCommunityBanned != nil { + return *m.BisCommunityBanned + } + return false +} + +func (m *CMsgClientIsLimitedAccount) GetBisLockedAccount() bool { + if m != nil && m.BisLockedAccount != nil { + return *m.BisLockedAccount + } + return false +} + +func (m *CMsgClientIsLimitedAccount) GetBisLimitedAccountAllowedToInviteFriends() bool { + if m != nil && m.BisLimitedAccountAllowedToInviteFriends != nil { + return *m.BisLimitedAccountAllowedToInviteFriends + } + return false +} + +type CMsgClientRequestFriendData struct { + PersonaStateRequested *uint32 `protobuf:"varint,1,opt,name=persona_state_requested" json:"persona_state_requested,omitempty"` + Friends []uint64 `protobuf:"fixed64,2,rep,name=friends" json:"friends,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestFriendData) Reset() { *m = CMsgClientRequestFriendData{} } +func (m *CMsgClientRequestFriendData) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestFriendData) ProtoMessage() {} +func (*CMsgClientRequestFriendData) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{46} } + +func (m *CMsgClientRequestFriendData) GetPersonaStateRequested() uint32 { + if m != nil && m.PersonaStateRequested != nil { + return *m.PersonaStateRequested + } + return 0 +} + +func (m *CMsgClientRequestFriendData) GetFriends() []uint64 { + if m != nil { + return m.Friends + } + return nil +} + +type CMsgClientChangeStatus struct { + PersonaState *uint32 `protobuf:"varint,1,opt,name=persona_state" json:"persona_state,omitempty"` + PlayerName *string `protobuf:"bytes,2,opt,name=player_name" json:"player_name,omitempty"` + IsAutoGeneratedName *bool `protobuf:"varint,3,opt,name=is_auto_generated_name" json:"is_auto_generated_name,omitempty"` + HighPriority *bool `protobuf:"varint,4,opt,name=high_priority" json:"high_priority,omitempty"` + PersonaSetByUser *bool `protobuf:"varint,5,opt,name=persona_set_by_user" json:"persona_set_by_user,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientChangeStatus) Reset() { *m = CMsgClientChangeStatus{} } +func (m *CMsgClientChangeStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgClientChangeStatus) ProtoMessage() {} +func (*CMsgClientChangeStatus) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{47} } + +func (m *CMsgClientChangeStatus) GetPersonaState() uint32 { + if m != nil && m.PersonaState != nil { + return *m.PersonaState + } + return 0 +} + +func (m *CMsgClientChangeStatus) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +func (m *CMsgClientChangeStatus) GetIsAutoGeneratedName() bool { + if m != nil && m.IsAutoGeneratedName != nil { + return *m.IsAutoGeneratedName + } + return false +} + +func (m *CMsgClientChangeStatus) GetHighPriority() bool { + if m != nil && m.HighPriority != nil { + return *m.HighPriority + } + return false +} + +func (m *CMsgClientChangeStatus) GetPersonaSetByUser() bool { + if m != nil && m.PersonaSetByUser != nil { + return *m.PersonaSetByUser + } + return false +} + +type CMsgPersonaChangeResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + PlayerName *string `protobuf:"bytes,2,opt,name=player_name" json:"player_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgPersonaChangeResponse) Reset() { *m = CMsgPersonaChangeResponse{} } +func (m *CMsgPersonaChangeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgPersonaChangeResponse) ProtoMessage() {} +func (*CMsgPersonaChangeResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{48} } + +func (m *CMsgPersonaChangeResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *CMsgPersonaChangeResponse) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +type CMsgClientPersonaState struct { + StatusFlags *uint32 `protobuf:"varint,1,opt,name=status_flags" json:"status_flags,omitempty"` + Friends []*CMsgClientPersonaState_Friend `protobuf:"bytes,2,rep,name=friends" json:"friends,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPersonaState) Reset() { *m = CMsgClientPersonaState{} } +func (m *CMsgClientPersonaState) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPersonaState) ProtoMessage() {} +func (*CMsgClientPersonaState) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{49} } + +func (m *CMsgClientPersonaState) GetStatusFlags() uint32 { + if m != nil && m.StatusFlags != nil { + return *m.StatusFlags + } + return 0 +} + +func (m *CMsgClientPersonaState) GetFriends() []*CMsgClientPersonaState_Friend { + if m != nil { + return m.Friends + } + return nil +} + +type CMsgClientPersonaState_Friend struct { + Friendid *uint64 `protobuf:"fixed64,1,opt,name=friendid" json:"friendid,omitempty"` + PersonaState *uint32 `protobuf:"varint,2,opt,name=persona_state" json:"persona_state,omitempty"` + GamePlayedAppId *uint32 `protobuf:"varint,3,opt,name=game_played_app_id" json:"game_played_app_id,omitempty"` + GameServerIp *uint32 `protobuf:"varint,4,opt,name=game_server_ip" json:"game_server_ip,omitempty"` + GameServerPort *uint32 `protobuf:"varint,5,opt,name=game_server_port" json:"game_server_port,omitempty"` + PersonaStateFlags *uint32 `protobuf:"varint,6,opt,name=persona_state_flags" json:"persona_state_flags,omitempty"` + OnlineSessionInstances *uint32 `protobuf:"varint,7,opt,name=online_session_instances" json:"online_session_instances,omitempty"` + PublishedInstanceId *uint32 `protobuf:"varint,8,opt,name=published_instance_id" json:"published_instance_id,omitempty"` + PersonaSetByUser *bool `protobuf:"varint,10,opt,name=persona_set_by_user" json:"persona_set_by_user,omitempty"` + PlayerName *string `protobuf:"bytes,15,opt,name=player_name" json:"player_name,omitempty"` + QueryPort *uint32 `protobuf:"varint,20,opt,name=query_port" json:"query_port,omitempty"` + SteamidSource *uint64 `protobuf:"fixed64,25,opt,name=steamid_source" json:"steamid_source,omitempty"` + AvatarHash []byte `protobuf:"bytes,31,opt,name=avatar_hash" json:"avatar_hash,omitempty"` + LastLogoff *uint32 `protobuf:"varint,45,opt,name=last_logoff" json:"last_logoff,omitempty"` + LastLogon *uint32 `protobuf:"varint,46,opt,name=last_logon" json:"last_logon,omitempty"` + ClanRank *uint32 `protobuf:"varint,50,opt,name=clan_rank" json:"clan_rank,omitempty"` + GameName *string `protobuf:"bytes,55,opt,name=game_name" json:"game_name,omitempty"` + Gameid *uint64 `protobuf:"fixed64,56,opt,name=gameid" json:"gameid,omitempty"` + GameDataBlob []byte `protobuf:"bytes,60,opt,name=game_data_blob" json:"game_data_blob,omitempty"` + ClanTag *string `protobuf:"bytes,65,opt,name=clan_tag" json:"clan_tag,omitempty"` + FacebookName *string `protobuf:"bytes,66,opt,name=facebook_name" json:"facebook_name,omitempty"` + FacebookId *uint64 `protobuf:"varint,67,opt,name=facebook_id" json:"facebook_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPersonaState_Friend) Reset() { *m = CMsgClientPersonaState_Friend{} } +func (m *CMsgClientPersonaState_Friend) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPersonaState_Friend) ProtoMessage() {} +func (*CMsgClientPersonaState_Friend) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{49, 0} +} + +func (m *CMsgClientPersonaState_Friend) GetFriendid() uint64 { + if m != nil && m.Friendid != nil { + return *m.Friendid + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetPersonaState() uint32 { + if m != nil && m.PersonaState != nil { + return *m.PersonaState + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetGamePlayedAppId() uint32 { + if m != nil && m.GamePlayedAppId != nil { + return *m.GamePlayedAppId + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetGameServerIp() uint32 { + if m != nil && m.GameServerIp != nil { + return *m.GameServerIp + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetGameServerPort() uint32 { + if m != nil && m.GameServerPort != nil { + return *m.GameServerPort + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetPersonaStateFlags() uint32 { + if m != nil && m.PersonaStateFlags != nil { + return *m.PersonaStateFlags + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetOnlineSessionInstances() uint32 { + if m != nil && m.OnlineSessionInstances != nil { + return *m.OnlineSessionInstances + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetPublishedInstanceId() uint32 { + if m != nil && m.PublishedInstanceId != nil { + return *m.PublishedInstanceId + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetPersonaSetByUser() bool { + if m != nil && m.PersonaSetByUser != nil { + return *m.PersonaSetByUser + } + return false +} + +func (m *CMsgClientPersonaState_Friend) GetPlayerName() string { + if m != nil && m.PlayerName != nil { + return *m.PlayerName + } + return "" +} + +func (m *CMsgClientPersonaState_Friend) GetQueryPort() uint32 { + if m != nil && m.QueryPort != nil { + return *m.QueryPort + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetSteamidSource() uint64 { + if m != nil && m.SteamidSource != nil { + return *m.SteamidSource + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetAvatarHash() []byte { + if m != nil { + return m.AvatarHash + } + return nil +} + +func (m *CMsgClientPersonaState_Friend) GetLastLogoff() uint32 { + if m != nil && m.LastLogoff != nil { + return *m.LastLogoff + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetLastLogon() uint32 { + if m != nil && m.LastLogon != nil { + return *m.LastLogon + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetClanRank() uint32 { + if m != nil && m.ClanRank != nil { + return *m.ClanRank + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetGameName() string { + if m != nil && m.GameName != nil { + return *m.GameName + } + return "" +} + +func (m *CMsgClientPersonaState_Friend) GetGameid() uint64 { + if m != nil && m.Gameid != nil { + return *m.Gameid + } + return 0 +} + +func (m *CMsgClientPersonaState_Friend) GetGameDataBlob() []byte { + if m != nil { + return m.GameDataBlob + } + return nil +} + +func (m *CMsgClientPersonaState_Friend) GetClanTag() string { + if m != nil && m.ClanTag != nil { + return *m.ClanTag + } + return "" +} + +func (m *CMsgClientPersonaState_Friend) GetFacebookName() string { + if m != nil && m.FacebookName != nil { + return *m.FacebookName + } + return "" +} + +func (m *CMsgClientPersonaState_Friend) GetFacebookId() uint64 { + if m != nil && m.FacebookId != nil { + return *m.FacebookId + } + return 0 +} + +type CMsgClientFriendProfileInfo struct { + SteamidFriend *uint64 `protobuf:"fixed64,1,opt,name=steamid_friend" json:"steamid_friend,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendProfileInfo) Reset() { *m = CMsgClientFriendProfileInfo{} } +func (m *CMsgClientFriendProfileInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendProfileInfo) ProtoMessage() {} +func (*CMsgClientFriendProfileInfo) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{50} } + +func (m *CMsgClientFriendProfileInfo) GetSteamidFriend() uint64 { + if m != nil && m.SteamidFriend != nil { + return *m.SteamidFriend + } + return 0 +} + +type CMsgClientFriendProfileInfoResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + SteamidFriend *uint64 `protobuf:"fixed64,2,opt,name=steamid_friend" json:"steamid_friend,omitempty"` + TimeCreated *uint32 `protobuf:"varint,3,opt,name=time_created" json:"time_created,omitempty"` + RealName *string `protobuf:"bytes,4,opt,name=real_name" json:"real_name,omitempty"` + CityName *string `protobuf:"bytes,5,opt,name=city_name" json:"city_name,omitempty"` + StateName *string `protobuf:"bytes,6,opt,name=state_name" json:"state_name,omitempty"` + CountryName *string `protobuf:"bytes,7,opt,name=country_name" json:"country_name,omitempty"` + Headline *string `protobuf:"bytes,8,opt,name=headline" json:"headline,omitempty"` + Summary *string `protobuf:"bytes,9,opt,name=summary" json:"summary,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendProfileInfoResponse) Reset() { *m = CMsgClientFriendProfileInfoResponse{} } +func (m *CMsgClientFriendProfileInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendProfileInfoResponse) ProtoMessage() {} +func (*CMsgClientFriendProfileInfoResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{51} +} + +const Default_CMsgClientFriendProfileInfoResponse_Eresult int32 = 2 + +func (m *CMsgClientFriendProfileInfoResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientFriendProfileInfoResponse_Eresult +} + +func (m *CMsgClientFriendProfileInfoResponse) GetSteamidFriend() uint64 { + if m != nil && m.SteamidFriend != nil { + return *m.SteamidFriend + } + return 0 +} + +func (m *CMsgClientFriendProfileInfoResponse) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *CMsgClientFriendProfileInfoResponse) GetRealName() string { + if m != nil && m.RealName != nil { + return *m.RealName + } + return "" +} + +func (m *CMsgClientFriendProfileInfoResponse) GetCityName() string { + if m != nil && m.CityName != nil { + return *m.CityName + } + return "" +} + +func (m *CMsgClientFriendProfileInfoResponse) GetStateName() string { + if m != nil && m.StateName != nil { + return *m.StateName + } + return "" +} + +func (m *CMsgClientFriendProfileInfoResponse) GetCountryName() string { + if m != nil && m.CountryName != nil { + return *m.CountryName + } + return "" +} + +func (m *CMsgClientFriendProfileInfoResponse) GetHeadline() string { + if m != nil && m.Headline != nil { + return *m.Headline + } + return "" +} + +func (m *CMsgClientFriendProfileInfoResponse) GetSummary() string { + if m != nil && m.Summary != nil { + return *m.Summary + } + return "" +} + +type CMsgClientServerList struct { + Servers []*CMsgClientServerList_Server `protobuf:"bytes,1,rep,name=servers" json:"servers,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServerList) Reset() { *m = CMsgClientServerList{} } +func (m *CMsgClientServerList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServerList) ProtoMessage() {} +func (*CMsgClientServerList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{52} } + +func (m *CMsgClientServerList) GetServers() []*CMsgClientServerList_Server { + if m != nil { + return m.Servers + } + return nil +} + +type CMsgClientServerList_Server struct { + ServerType *uint32 `protobuf:"varint,1,opt,name=server_type" json:"server_type,omitempty"` + ServerIp *uint32 `protobuf:"varint,2,opt,name=server_ip" json:"server_ip,omitempty"` + ServerPort *uint32 `protobuf:"varint,3,opt,name=server_port" json:"server_port,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServerList_Server) Reset() { *m = CMsgClientServerList_Server{} } +func (m *CMsgClientServerList_Server) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServerList_Server) ProtoMessage() {} +func (*CMsgClientServerList_Server) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{52, 0} } + +func (m *CMsgClientServerList_Server) GetServerType() uint32 { + if m != nil && m.ServerType != nil { + return *m.ServerType + } + return 0 +} + +func (m *CMsgClientServerList_Server) GetServerIp() uint32 { + if m != nil && m.ServerIp != nil { + return *m.ServerIp + } + return 0 +} + +func (m *CMsgClientServerList_Server) GetServerPort() uint32 { + if m != nil && m.ServerPort != nil { + return *m.ServerPort + } + return 0 +} + +type CMsgClientRequestedClientStats struct { + StatsToSend []*CMsgClientRequestedClientStats_StatsToSend `protobuf:"bytes,1,rep,name=stats_to_send" json:"stats_to_send,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestedClientStats) Reset() { *m = CMsgClientRequestedClientStats{} } +func (m *CMsgClientRequestedClientStats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestedClientStats) ProtoMessage() {} +func (*CMsgClientRequestedClientStats) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{53} } + +func (m *CMsgClientRequestedClientStats) GetStatsToSend() []*CMsgClientRequestedClientStats_StatsToSend { + if m != nil { + return m.StatsToSend + } + return nil +} + +type CMsgClientRequestedClientStats_StatsToSend struct { + ClientStat *uint32 `protobuf:"varint,1,opt,name=client_stat" json:"client_stat,omitempty"` + StatAggregateMethod *uint32 `protobuf:"varint,2,opt,name=stat_aggregate_method" json:"stat_aggregate_method,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestedClientStats_StatsToSend) Reset() { + *m = CMsgClientRequestedClientStats_StatsToSend{} +} +func (m *CMsgClientRequestedClientStats_StatsToSend) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientRequestedClientStats_StatsToSend) ProtoMessage() {} +func (*CMsgClientRequestedClientStats_StatsToSend) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{53, 0} +} + +func (m *CMsgClientRequestedClientStats_StatsToSend) GetClientStat() uint32 { + if m != nil && m.ClientStat != nil { + return *m.ClientStat + } + return 0 +} + +func (m *CMsgClientRequestedClientStats_StatsToSend) GetStatAggregateMethod() uint32 { + if m != nil && m.StatAggregateMethod != nil { + return *m.StatAggregateMethod + } + return 0 +} + +type CMsgClientStat2 struct { + StatDetail []*CMsgClientStat2_StatDetail `protobuf:"bytes,1,rep,name=stat_detail" json:"stat_detail,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStat2) Reset() { *m = CMsgClientStat2{} } +func (m *CMsgClientStat2) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStat2) ProtoMessage() {} +func (*CMsgClientStat2) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{54} } + +func (m *CMsgClientStat2) GetStatDetail() []*CMsgClientStat2_StatDetail { + if m != nil { + return m.StatDetail + } + return nil +} + +type CMsgClientStat2_StatDetail struct { + ClientStat *uint32 `protobuf:"varint,1,opt,name=client_stat" json:"client_stat,omitempty"` + LlValue *int64 `protobuf:"varint,2,opt,name=ll_value" json:"ll_value,omitempty"` + TimeOfDay *uint32 `protobuf:"varint,3,opt,name=time_of_day" json:"time_of_day,omitempty"` + CellId *uint32 `protobuf:"varint,4,opt,name=cell_id" json:"cell_id,omitempty"` + DepotId *uint32 `protobuf:"varint,5,opt,name=depot_id" json:"depot_id,omitempty"` + AppId *uint32 `protobuf:"varint,6,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStat2_StatDetail) Reset() { *m = CMsgClientStat2_StatDetail{} } +func (m *CMsgClientStat2_StatDetail) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStat2_StatDetail) ProtoMessage() {} +func (*CMsgClientStat2_StatDetail) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{54, 0} } + +func (m *CMsgClientStat2_StatDetail) GetClientStat() uint32 { + if m != nil && m.ClientStat != nil { + return *m.ClientStat + } + return 0 +} + +func (m *CMsgClientStat2_StatDetail) GetLlValue() int64 { + if m != nil && m.LlValue != nil { + return *m.LlValue + } + return 0 +} + +func (m *CMsgClientStat2_StatDetail) GetTimeOfDay() uint32 { + if m != nil && m.TimeOfDay != nil { + return *m.TimeOfDay + } + return 0 +} + +func (m *CMsgClientStat2_StatDetail) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CMsgClientStat2_StatDetail) GetDepotId() uint32 { + if m != nil && m.DepotId != nil { + return *m.DepotId + } + return 0 +} + +func (m *CMsgClientStat2_StatDetail) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientMMSCreateLobby struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + MaxMembers *int32 `protobuf:"varint,2,opt,name=max_members" json:"max_members,omitempty"` + LobbyType *int32 `protobuf:"varint,3,opt,name=lobby_type" json:"lobby_type,omitempty"` + LobbyFlags *int32 `protobuf:"varint,4,opt,name=lobby_flags" json:"lobby_flags,omitempty"` + CellId *uint32 `protobuf:"varint,5,opt,name=cell_id" json:"cell_id,omitempty"` + PublicIp *uint32 `protobuf:"varint,6,opt,name=public_ip" json:"public_ip,omitempty"` + Metadata []byte `protobuf:"bytes,7,opt,name=metadata" json:"metadata,omitempty"` + PersonaNameOwner *string `protobuf:"bytes,8,opt,name=persona_name_owner" json:"persona_name_owner,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSCreateLobby) Reset() { *m = CMsgClientMMSCreateLobby{} } +func (m *CMsgClientMMSCreateLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSCreateLobby) ProtoMessage() {} +func (*CMsgClientMMSCreateLobby) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{55} } + +func (m *CMsgClientMMSCreateLobby) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSCreateLobby) GetMaxMembers() int32 { + if m != nil && m.MaxMembers != nil { + return *m.MaxMembers + } + return 0 +} + +func (m *CMsgClientMMSCreateLobby) GetLobbyType() int32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgClientMMSCreateLobby) GetLobbyFlags() int32 { + if m != nil && m.LobbyFlags != nil { + return *m.LobbyFlags + } + return 0 +} + +func (m *CMsgClientMMSCreateLobby) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CMsgClientMMSCreateLobby) GetPublicIp() uint32 { + if m != nil && m.PublicIp != nil { + return *m.PublicIp + } + return 0 +} + +func (m *CMsgClientMMSCreateLobby) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + +func (m *CMsgClientMMSCreateLobby) GetPersonaNameOwner() string { + if m != nil && m.PersonaNameOwner != nil { + return *m.PersonaNameOwner + } + return "" +} + +type CMsgClientMMSCreateLobbyResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + Eresult *int32 `protobuf:"varint,3,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSCreateLobbyResponse) Reset() { *m = CMsgClientMMSCreateLobbyResponse{} } +func (m *CMsgClientMMSCreateLobbyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSCreateLobbyResponse) ProtoMessage() {} +func (*CMsgClientMMSCreateLobbyResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{56} +} + +const Default_CMsgClientMMSCreateLobbyResponse_Eresult int32 = 2 + +func (m *CMsgClientMMSCreateLobbyResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSCreateLobbyResponse) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSCreateLobbyResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientMMSCreateLobbyResponse_Eresult +} + +type CMsgClientMMSJoinLobby struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + PersonaName *string `protobuf:"bytes,3,opt,name=persona_name" json:"persona_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSJoinLobby) Reset() { *m = CMsgClientMMSJoinLobby{} } +func (m *CMsgClientMMSJoinLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSJoinLobby) ProtoMessage() {} +func (*CMsgClientMMSJoinLobby) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{57} } + +func (m *CMsgClientMMSJoinLobby) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSJoinLobby) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSJoinLobby) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +type CMsgClientMMSJoinLobbyResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + ChatRoomEnterResponse *int32 `protobuf:"varint,3,opt,name=chat_room_enter_response" json:"chat_room_enter_response,omitempty"` + MaxMembers *int32 `protobuf:"varint,4,opt,name=max_members" json:"max_members,omitempty"` + LobbyType *int32 `protobuf:"varint,5,opt,name=lobby_type" json:"lobby_type,omitempty"` + LobbyFlags *int32 `protobuf:"varint,6,opt,name=lobby_flags" json:"lobby_flags,omitempty"` + SteamIdOwner *uint64 `protobuf:"fixed64,7,opt,name=steam_id_owner" json:"steam_id_owner,omitempty"` + Metadata []byte `protobuf:"bytes,8,opt,name=metadata" json:"metadata,omitempty"` + Members []*CMsgClientMMSJoinLobbyResponse_Member `protobuf:"bytes,9,rep,name=members" json:"members,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSJoinLobbyResponse) Reset() { *m = CMsgClientMMSJoinLobbyResponse{} } +func (m *CMsgClientMMSJoinLobbyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSJoinLobbyResponse) ProtoMessage() {} +func (*CMsgClientMMSJoinLobbyResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{58} } + +func (m *CMsgClientMMSJoinLobbyResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetChatRoomEnterResponse() int32 { + if m != nil && m.ChatRoomEnterResponse != nil { + return *m.ChatRoomEnterResponse + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetMaxMembers() int32 { + if m != nil && m.MaxMembers != nil { + return *m.MaxMembers + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetLobbyType() int32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetLobbyFlags() int32 { + if m != nil && m.LobbyFlags != nil { + return *m.LobbyFlags + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetSteamIdOwner() uint64 { + if m != nil && m.SteamIdOwner != nil { + return *m.SteamIdOwner + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + +func (m *CMsgClientMMSJoinLobbyResponse) GetMembers() []*CMsgClientMMSJoinLobbyResponse_Member { + if m != nil { + return m.Members + } + return nil +} + +type CMsgClientMMSJoinLobbyResponse_Member struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + PersonaName *string `protobuf:"bytes,2,opt,name=persona_name" json:"persona_name,omitempty"` + Metadata []byte `protobuf:"bytes,3,opt,name=metadata" json:"metadata,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSJoinLobbyResponse_Member) Reset() { *m = CMsgClientMMSJoinLobbyResponse_Member{} } +func (m *CMsgClientMMSJoinLobbyResponse_Member) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSJoinLobbyResponse_Member) ProtoMessage() {} +func (*CMsgClientMMSJoinLobbyResponse_Member) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{58, 0} +} + +func (m *CMsgClientMMSJoinLobbyResponse_Member) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgClientMMSJoinLobbyResponse_Member) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgClientMMSJoinLobbyResponse_Member) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + +type CMsgClientMMSLeaveLobby struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSLeaveLobby) Reset() { *m = CMsgClientMMSLeaveLobby{} } +func (m *CMsgClientMMSLeaveLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSLeaveLobby) ProtoMessage() {} +func (*CMsgClientMMSLeaveLobby) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{59} } + +func (m *CMsgClientMMSLeaveLobby) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSLeaveLobby) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +type CMsgClientMMSLeaveLobbyResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + Eresult *int32 `protobuf:"varint,3,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSLeaveLobbyResponse) Reset() { *m = CMsgClientMMSLeaveLobbyResponse{} } +func (m *CMsgClientMMSLeaveLobbyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSLeaveLobbyResponse) ProtoMessage() {} +func (*CMsgClientMMSLeaveLobbyResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{60} +} + +const Default_CMsgClientMMSLeaveLobbyResponse_Eresult int32 = 2 + +func (m *CMsgClientMMSLeaveLobbyResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSLeaveLobbyResponse) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSLeaveLobbyResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientMMSLeaveLobbyResponse_Eresult +} + +type CMsgClientMMSGetLobbyList struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + NumLobbiesRequested *int32 `protobuf:"varint,3,opt,name=num_lobbies_requested" json:"num_lobbies_requested,omitempty"` + CellId *uint32 `protobuf:"varint,4,opt,name=cell_id" json:"cell_id,omitempty"` + PublicIp *uint32 `protobuf:"varint,5,opt,name=public_ip" json:"public_ip,omitempty"` + Filters []*CMsgClientMMSGetLobbyList_Filter `protobuf:"bytes,6,rep,name=filters" json:"filters,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSGetLobbyList) Reset() { *m = CMsgClientMMSGetLobbyList{} } +func (m *CMsgClientMMSGetLobbyList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSGetLobbyList) ProtoMessage() {} +func (*CMsgClientMMSGetLobbyList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{61} } + +func (m *CMsgClientMMSGetLobbyList) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyList) GetNumLobbiesRequested() int32 { + if m != nil && m.NumLobbiesRequested != nil { + return *m.NumLobbiesRequested + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyList) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyList) GetPublicIp() uint32 { + if m != nil && m.PublicIp != nil { + return *m.PublicIp + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyList) GetFilters() []*CMsgClientMMSGetLobbyList_Filter { + if m != nil { + return m.Filters + } + return nil +} + +type CMsgClientMMSGetLobbyList_Filter struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + Comparision *int32 `protobuf:"varint,3,opt,name=comparision" json:"comparision,omitempty"` + FilterType *int32 `protobuf:"varint,4,opt,name=filter_type" json:"filter_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSGetLobbyList_Filter) Reset() { *m = CMsgClientMMSGetLobbyList_Filter{} } +func (m *CMsgClientMMSGetLobbyList_Filter) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSGetLobbyList_Filter) ProtoMessage() {} +func (*CMsgClientMMSGetLobbyList_Filter) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{61, 0} +} + +func (m *CMsgClientMMSGetLobbyList_Filter) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *CMsgClientMMSGetLobbyList_Filter) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +func (m *CMsgClientMMSGetLobbyList_Filter) GetComparision() int32 { + if m != nil && m.Comparision != nil { + return *m.Comparision + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyList_Filter) GetFilterType() int32 { + if m != nil && m.FilterType != nil { + return *m.FilterType + } + return 0 +} + +type CMsgClientMMSGetLobbyListResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + Eresult *int32 `protobuf:"varint,3,opt,name=eresult,def=2" json:"eresult,omitempty"` + Lobbies []*CMsgClientMMSGetLobbyListResponse_Lobby `protobuf:"bytes,4,rep,name=lobbies" json:"lobbies,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSGetLobbyListResponse) Reset() { *m = CMsgClientMMSGetLobbyListResponse{} } +func (m *CMsgClientMMSGetLobbyListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSGetLobbyListResponse) ProtoMessage() {} +func (*CMsgClientMMSGetLobbyListResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{62} +} + +const Default_CMsgClientMMSGetLobbyListResponse_Eresult int32 = 2 + +func (m *CMsgClientMMSGetLobbyListResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyListResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientMMSGetLobbyListResponse_Eresult +} + +func (m *CMsgClientMMSGetLobbyListResponse) GetLobbies() []*CMsgClientMMSGetLobbyListResponse_Lobby { + if m != nil { + return m.Lobbies + } + return nil +} + +type CMsgClientMMSGetLobbyListResponse_Lobby struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + MaxMembers *int32 `protobuf:"varint,2,opt,name=max_members" json:"max_members,omitempty"` + LobbyType *int32 `protobuf:"varint,3,opt,name=lobby_type" json:"lobby_type,omitempty"` + LobbyFlags *int32 `protobuf:"varint,4,opt,name=lobby_flags" json:"lobby_flags,omitempty"` + Metadata []byte `protobuf:"bytes,5,opt,name=metadata" json:"metadata,omitempty"` + NumMembers *int32 `protobuf:"varint,6,opt,name=num_members" json:"num_members,omitempty"` + Distance *float32 `protobuf:"fixed32,7,opt,name=distance" json:"distance,omitempty"` + Weight *int64 `protobuf:"varint,8,opt,name=weight" json:"weight,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) Reset() { + *m = CMsgClientMMSGetLobbyListResponse_Lobby{} +} +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSGetLobbyListResponse_Lobby) ProtoMessage() {} +func (*CMsgClientMMSGetLobbyListResponse_Lobby) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{62, 0} +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetMaxMembers() int32 { + if m != nil && m.MaxMembers != nil { + return *m.MaxMembers + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetLobbyType() int32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetLobbyFlags() int32 { + if m != nil && m.LobbyFlags != nil { + return *m.LobbyFlags + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetNumMembers() int32 { + if m != nil && m.NumMembers != nil { + return *m.NumMembers + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetDistance() float32 { + if m != nil && m.Distance != nil { + return *m.Distance + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyListResponse_Lobby) GetWeight() int64 { + if m != nil && m.Weight != nil { + return *m.Weight + } + return 0 +} + +type CMsgClientMMSSetLobbyData struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdMember *uint64 `protobuf:"fixed64,3,opt,name=steam_id_member" json:"steam_id_member,omitempty"` + MaxMembers *int32 `protobuf:"varint,4,opt,name=max_members" json:"max_members,omitempty"` + LobbyType *int32 `protobuf:"varint,5,opt,name=lobby_type" json:"lobby_type,omitempty"` + LobbyFlags *int32 `protobuf:"varint,6,opt,name=lobby_flags" json:"lobby_flags,omitempty"` + Metadata []byte `protobuf:"bytes,7,opt,name=metadata" json:"metadata,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSSetLobbyData) Reset() { *m = CMsgClientMMSSetLobbyData{} } +func (m *CMsgClientMMSSetLobbyData) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSSetLobbyData) ProtoMessage() {} +func (*CMsgClientMMSSetLobbyData) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{63} } + +func (m *CMsgClientMMSSetLobbyData) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyData) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyData) GetSteamIdMember() uint64 { + if m != nil && m.SteamIdMember != nil { + return *m.SteamIdMember + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyData) GetMaxMembers() int32 { + if m != nil && m.MaxMembers != nil { + return *m.MaxMembers + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyData) GetLobbyType() int32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyData) GetLobbyFlags() int32 { + if m != nil && m.LobbyFlags != nil { + return *m.LobbyFlags + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyData) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + +type CMsgClientMMSSetLobbyDataResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + Eresult *int32 `protobuf:"varint,3,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSSetLobbyDataResponse) Reset() { *m = CMsgClientMMSSetLobbyDataResponse{} } +func (m *CMsgClientMMSSetLobbyDataResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSSetLobbyDataResponse) ProtoMessage() {} +func (*CMsgClientMMSSetLobbyDataResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{64} +} + +const Default_CMsgClientMMSSetLobbyDataResponse_Eresult int32 = 2 + +func (m *CMsgClientMMSSetLobbyDataResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyDataResponse) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyDataResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientMMSSetLobbyDataResponse_Eresult +} + +type CMsgClientMMSGetLobbyData struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSGetLobbyData) Reset() { *m = CMsgClientMMSGetLobbyData{} } +func (m *CMsgClientMMSGetLobbyData) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSGetLobbyData) ProtoMessage() {} +func (*CMsgClientMMSGetLobbyData) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{65} } + +func (m *CMsgClientMMSGetLobbyData) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSGetLobbyData) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +type CMsgClientMMSLobbyData struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + NumMembers *int32 `protobuf:"varint,3,opt,name=num_members" json:"num_members,omitempty"` + MaxMembers *int32 `protobuf:"varint,4,opt,name=max_members" json:"max_members,omitempty"` + LobbyType *int32 `protobuf:"varint,5,opt,name=lobby_type" json:"lobby_type,omitempty"` + LobbyFlags *int32 `protobuf:"varint,6,opt,name=lobby_flags" json:"lobby_flags,omitempty"` + SteamIdOwner *uint64 `protobuf:"fixed64,7,opt,name=steam_id_owner" json:"steam_id_owner,omitempty"` + Metadata []byte `protobuf:"bytes,8,opt,name=metadata" json:"metadata,omitempty"` + Members []*CMsgClientMMSLobbyData_Member `protobuf:"bytes,9,rep,name=members" json:"members,omitempty"` + LobbyCellid *uint32 `protobuf:"varint,10,opt,name=lobby_cellid" json:"lobby_cellid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSLobbyData) Reset() { *m = CMsgClientMMSLobbyData{} } +func (m *CMsgClientMMSLobbyData) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSLobbyData) ProtoMessage() {} +func (*CMsgClientMMSLobbyData) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{66} } + +func (m *CMsgClientMMSLobbyData) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSLobbyData) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSLobbyData) GetNumMembers() int32 { + if m != nil && m.NumMembers != nil { + return *m.NumMembers + } + return 0 +} + +func (m *CMsgClientMMSLobbyData) GetMaxMembers() int32 { + if m != nil && m.MaxMembers != nil { + return *m.MaxMembers + } + return 0 +} + +func (m *CMsgClientMMSLobbyData) GetLobbyType() int32 { + if m != nil && m.LobbyType != nil { + return *m.LobbyType + } + return 0 +} + +func (m *CMsgClientMMSLobbyData) GetLobbyFlags() int32 { + if m != nil && m.LobbyFlags != nil { + return *m.LobbyFlags + } + return 0 +} + +func (m *CMsgClientMMSLobbyData) GetSteamIdOwner() uint64 { + if m != nil && m.SteamIdOwner != nil { + return *m.SteamIdOwner + } + return 0 +} + +func (m *CMsgClientMMSLobbyData) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + +func (m *CMsgClientMMSLobbyData) GetMembers() []*CMsgClientMMSLobbyData_Member { + if m != nil { + return m.Members + } + return nil +} + +func (m *CMsgClientMMSLobbyData) GetLobbyCellid() uint32 { + if m != nil && m.LobbyCellid != nil { + return *m.LobbyCellid + } + return 0 +} + +type CMsgClientMMSLobbyData_Member struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + PersonaName *string `protobuf:"bytes,2,opt,name=persona_name" json:"persona_name,omitempty"` + Metadata []byte `protobuf:"bytes,3,opt,name=metadata" json:"metadata,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSLobbyData_Member) Reset() { *m = CMsgClientMMSLobbyData_Member{} } +func (m *CMsgClientMMSLobbyData_Member) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSLobbyData_Member) ProtoMessage() {} +func (*CMsgClientMMSLobbyData_Member) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{66, 0} +} + +func (m *CMsgClientMMSLobbyData_Member) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgClientMMSLobbyData_Member) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +func (m *CMsgClientMMSLobbyData_Member) GetMetadata() []byte { + if m != nil { + return m.Metadata + } + return nil +} + +type CMsgClientMMSSendLobbyChatMsg struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdTarget *uint64 `protobuf:"fixed64,3,opt,name=steam_id_target" json:"steam_id_target,omitempty"` + LobbyMessage []byte `protobuf:"bytes,4,opt,name=lobby_message" json:"lobby_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSSendLobbyChatMsg) Reset() { *m = CMsgClientMMSSendLobbyChatMsg{} } +func (m *CMsgClientMMSSendLobbyChatMsg) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSSendLobbyChatMsg) ProtoMessage() {} +func (*CMsgClientMMSSendLobbyChatMsg) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{67} } + +func (m *CMsgClientMMSSendLobbyChatMsg) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSSendLobbyChatMsg) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSSendLobbyChatMsg) GetSteamIdTarget() uint64 { + if m != nil && m.SteamIdTarget != nil { + return *m.SteamIdTarget + } + return 0 +} + +func (m *CMsgClientMMSSendLobbyChatMsg) GetLobbyMessage() []byte { + if m != nil { + return m.LobbyMessage + } + return nil +} + +type CMsgClientMMSLobbyChatMsg struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdSender *uint64 `protobuf:"fixed64,3,opt,name=steam_id_sender" json:"steam_id_sender,omitempty"` + LobbyMessage []byte `protobuf:"bytes,4,opt,name=lobby_message" json:"lobby_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSLobbyChatMsg) Reset() { *m = CMsgClientMMSLobbyChatMsg{} } +func (m *CMsgClientMMSLobbyChatMsg) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSLobbyChatMsg) ProtoMessage() {} +func (*CMsgClientMMSLobbyChatMsg) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{68} } + +func (m *CMsgClientMMSLobbyChatMsg) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSLobbyChatMsg) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSLobbyChatMsg) GetSteamIdSender() uint64 { + if m != nil && m.SteamIdSender != nil { + return *m.SteamIdSender + } + return 0 +} + +func (m *CMsgClientMMSLobbyChatMsg) GetLobbyMessage() []byte { + if m != nil { + return m.LobbyMessage + } + return nil +} + +type CMsgClientMMSSetLobbyOwner struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdNewOwner *uint64 `protobuf:"fixed64,3,opt,name=steam_id_new_owner" json:"steam_id_new_owner,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSSetLobbyOwner) Reset() { *m = CMsgClientMMSSetLobbyOwner{} } +func (m *CMsgClientMMSSetLobbyOwner) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSSetLobbyOwner) ProtoMessage() {} +func (*CMsgClientMMSSetLobbyOwner) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{69} } + +func (m *CMsgClientMMSSetLobbyOwner) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyOwner) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyOwner) GetSteamIdNewOwner() uint64 { + if m != nil && m.SteamIdNewOwner != nil { + return *m.SteamIdNewOwner + } + return 0 +} + +type CMsgClientMMSSetLobbyOwnerResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + Eresult *int32 `protobuf:"varint,3,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSSetLobbyOwnerResponse) Reset() { *m = CMsgClientMMSSetLobbyOwnerResponse{} } +func (m *CMsgClientMMSSetLobbyOwnerResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSSetLobbyOwnerResponse) ProtoMessage() {} +func (*CMsgClientMMSSetLobbyOwnerResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{70} +} + +const Default_CMsgClientMMSSetLobbyOwnerResponse_Eresult int32 = 2 + +func (m *CMsgClientMMSSetLobbyOwnerResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyOwnerResponse) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyOwnerResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientMMSSetLobbyOwnerResponse_Eresult +} + +type CMsgClientMMSSetLobbyLinked struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdLobby2 *uint64 `protobuf:"fixed64,3,opt,name=steam_id_lobby2" json:"steam_id_lobby2,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSSetLobbyLinked) Reset() { *m = CMsgClientMMSSetLobbyLinked{} } +func (m *CMsgClientMMSSetLobbyLinked) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSSetLobbyLinked) ProtoMessage() {} +func (*CMsgClientMMSSetLobbyLinked) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{71} } + +func (m *CMsgClientMMSSetLobbyLinked) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyLinked) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyLinked) GetSteamIdLobby2() uint64 { + if m != nil && m.SteamIdLobby2 != nil { + return *m.SteamIdLobby2 + } + return 0 +} + +type CMsgClientMMSSetLobbyGameServer struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + GameServerIp *uint32 `protobuf:"varint,3,opt,name=game_server_ip" json:"game_server_ip,omitempty"` + GameServerPort *uint32 `protobuf:"varint,4,opt,name=game_server_port" json:"game_server_port,omitempty"` + GameServerSteamId *uint64 `protobuf:"fixed64,5,opt,name=game_server_steam_id" json:"game_server_steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSSetLobbyGameServer) Reset() { *m = CMsgClientMMSSetLobbyGameServer{} } +func (m *CMsgClientMMSSetLobbyGameServer) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSSetLobbyGameServer) ProtoMessage() {} +func (*CMsgClientMMSSetLobbyGameServer) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{72} +} + +func (m *CMsgClientMMSSetLobbyGameServer) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyGameServer) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyGameServer) GetGameServerIp() uint32 { + if m != nil && m.GameServerIp != nil { + return *m.GameServerIp + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyGameServer) GetGameServerPort() uint32 { + if m != nil && m.GameServerPort != nil { + return *m.GameServerPort + } + return 0 +} + +func (m *CMsgClientMMSSetLobbyGameServer) GetGameServerSteamId() uint64 { + if m != nil && m.GameServerSteamId != nil { + return *m.GameServerSteamId + } + return 0 +} + +type CMsgClientMMSLobbyGameServerSet struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + GameServerIp *uint32 `protobuf:"varint,3,opt,name=game_server_ip" json:"game_server_ip,omitempty"` + GameServerPort *uint32 `protobuf:"varint,4,opt,name=game_server_port" json:"game_server_port,omitempty"` + GameServerSteamId *uint64 `protobuf:"fixed64,5,opt,name=game_server_steam_id" json:"game_server_steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSLobbyGameServerSet) Reset() { *m = CMsgClientMMSLobbyGameServerSet{} } +func (m *CMsgClientMMSLobbyGameServerSet) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSLobbyGameServerSet) ProtoMessage() {} +func (*CMsgClientMMSLobbyGameServerSet) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{73} +} + +func (m *CMsgClientMMSLobbyGameServerSet) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSLobbyGameServerSet) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSLobbyGameServerSet) GetGameServerIp() uint32 { + if m != nil && m.GameServerIp != nil { + return *m.GameServerIp + } + return 0 +} + +func (m *CMsgClientMMSLobbyGameServerSet) GetGameServerPort() uint32 { + if m != nil && m.GameServerPort != nil { + return *m.GameServerPort + } + return 0 +} + +func (m *CMsgClientMMSLobbyGameServerSet) GetGameServerSteamId() uint64 { + if m != nil && m.GameServerSteamId != nil { + return *m.GameServerSteamId + } + return 0 +} + +type CMsgClientMMSUserJoinedLobby struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdUser *uint64 `protobuf:"fixed64,3,opt,name=steam_id_user" json:"steam_id_user,omitempty"` + PersonaName *string `protobuf:"bytes,4,opt,name=persona_name" json:"persona_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSUserJoinedLobby) Reset() { *m = CMsgClientMMSUserJoinedLobby{} } +func (m *CMsgClientMMSUserJoinedLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSUserJoinedLobby) ProtoMessage() {} +func (*CMsgClientMMSUserJoinedLobby) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{74} } + +func (m *CMsgClientMMSUserJoinedLobby) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSUserJoinedLobby) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSUserJoinedLobby) GetSteamIdUser() uint64 { + if m != nil && m.SteamIdUser != nil { + return *m.SteamIdUser + } + return 0 +} + +func (m *CMsgClientMMSUserJoinedLobby) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +type CMsgClientMMSUserLeftLobby struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdUser *uint64 `protobuf:"fixed64,3,opt,name=steam_id_user" json:"steam_id_user,omitempty"` + PersonaName *string `protobuf:"bytes,4,opt,name=persona_name" json:"persona_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSUserLeftLobby) Reset() { *m = CMsgClientMMSUserLeftLobby{} } +func (m *CMsgClientMMSUserLeftLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSUserLeftLobby) ProtoMessage() {} +func (*CMsgClientMMSUserLeftLobby) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{75} } + +func (m *CMsgClientMMSUserLeftLobby) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSUserLeftLobby) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSUserLeftLobby) GetSteamIdUser() uint64 { + if m != nil && m.SteamIdUser != nil { + return *m.SteamIdUser + } + return 0 +} + +func (m *CMsgClientMMSUserLeftLobby) GetPersonaName() string { + if m != nil && m.PersonaName != nil { + return *m.PersonaName + } + return "" +} + +type CMsgClientMMSInviteToLobby struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SteamIdLobby *uint64 `protobuf:"fixed64,2,opt,name=steam_id_lobby" json:"steam_id_lobby,omitempty"` + SteamIdUserInvited *uint64 `protobuf:"fixed64,3,opt,name=steam_id_user_invited" json:"steam_id_user_invited,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientMMSInviteToLobby) Reset() { *m = CMsgClientMMSInviteToLobby{} } +func (m *CMsgClientMMSInviteToLobby) String() string { return proto.CompactTextString(m) } +func (*CMsgClientMMSInviteToLobby) ProtoMessage() {} +func (*CMsgClientMMSInviteToLobby) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{76} } + +func (m *CMsgClientMMSInviteToLobby) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientMMSInviteToLobby) GetSteamIdLobby() uint64 { + if m != nil && m.SteamIdLobby != nil { + return *m.SteamIdLobby + } + return 0 +} + +func (m *CMsgClientMMSInviteToLobby) GetSteamIdUserInvited() uint64 { + if m != nil && m.SteamIdUserInvited != nil { + return *m.SteamIdUserInvited + } + return 0 +} + +type CMsgClientUDSInviteToGame struct { + SteamIdDest *uint64 `protobuf:"fixed64,1,opt,name=steam_id_dest" json:"steam_id_dest,omitempty"` + SteamIdSrc *uint64 `protobuf:"fixed64,2,opt,name=steam_id_src" json:"steam_id_src,omitempty"` + ConnectString *string `protobuf:"bytes,3,opt,name=connect_string" json:"connect_string,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUDSInviteToGame) Reset() { *m = CMsgClientUDSInviteToGame{} } +func (m *CMsgClientUDSInviteToGame) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUDSInviteToGame) ProtoMessage() {} +func (*CMsgClientUDSInviteToGame) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{77} } + +func (m *CMsgClientUDSInviteToGame) GetSteamIdDest() uint64 { + if m != nil && m.SteamIdDest != nil { + return *m.SteamIdDest + } + return 0 +} + +func (m *CMsgClientUDSInviteToGame) GetSteamIdSrc() uint64 { + if m != nil && m.SteamIdSrc != nil { + return *m.SteamIdSrc + } + return 0 +} + +func (m *CMsgClientUDSInviteToGame) GetConnectString() string { + if m != nil && m.ConnectString != nil { + return *m.ConnectString + } + return "" +} + +type CMsgClientChatInvite struct { + SteamIdInvited *uint64 `protobuf:"fixed64,1,opt,name=steam_id_invited" json:"steam_id_invited,omitempty"` + SteamIdChat *uint64 `protobuf:"fixed64,2,opt,name=steam_id_chat" json:"steam_id_chat,omitempty"` + SteamIdPatron *uint64 `protobuf:"fixed64,3,opt,name=steam_id_patron" json:"steam_id_patron,omitempty"` + ChatroomType *int32 `protobuf:"varint,4,opt,name=chatroom_type" json:"chatroom_type,omitempty"` + SteamIdFriendChat *uint64 `protobuf:"fixed64,5,opt,name=steam_id_friend_chat" json:"steam_id_friend_chat,omitempty"` + ChatName *string `protobuf:"bytes,6,opt,name=chat_name" json:"chat_name,omitempty"` + GameId *uint64 `protobuf:"fixed64,7,opt,name=game_id" json:"game_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientChatInvite) Reset() { *m = CMsgClientChatInvite{} } +func (m *CMsgClientChatInvite) String() string { return proto.CompactTextString(m) } +func (*CMsgClientChatInvite) ProtoMessage() {} +func (*CMsgClientChatInvite) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{78} } + +func (m *CMsgClientChatInvite) GetSteamIdInvited() uint64 { + if m != nil && m.SteamIdInvited != nil { + return *m.SteamIdInvited + } + return 0 +} + +func (m *CMsgClientChatInvite) GetSteamIdChat() uint64 { + if m != nil && m.SteamIdChat != nil { + return *m.SteamIdChat + } + return 0 +} + +func (m *CMsgClientChatInvite) GetSteamIdPatron() uint64 { + if m != nil && m.SteamIdPatron != nil { + return *m.SteamIdPatron + } + return 0 +} + +func (m *CMsgClientChatInvite) GetChatroomType() int32 { + if m != nil && m.ChatroomType != nil { + return *m.ChatroomType + } + return 0 +} + +func (m *CMsgClientChatInvite) GetSteamIdFriendChat() uint64 { + if m != nil && m.SteamIdFriendChat != nil { + return *m.SteamIdFriendChat + } + return 0 +} + +func (m *CMsgClientChatInvite) GetChatName() string { + if m != nil && m.ChatName != nil { + return *m.ChatName + } + return "" +} + +func (m *CMsgClientChatInvite) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +type CMsgClientConnectionStats struct { + StatsLogon *CMsgClientConnectionStats_Stats_Logon `protobuf:"bytes,1,opt,name=stats_logon" json:"stats_logon,omitempty"` + StatsVconn *CMsgClientConnectionStats_Stats_VConn `protobuf:"bytes,2,opt,name=stats_vconn" json:"stats_vconn,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientConnectionStats) Reset() { *m = CMsgClientConnectionStats{} } +func (m *CMsgClientConnectionStats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientConnectionStats) ProtoMessage() {} +func (*CMsgClientConnectionStats) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{79} } + +func (m *CMsgClientConnectionStats) GetStatsLogon() *CMsgClientConnectionStats_Stats_Logon { + if m != nil { + return m.StatsLogon + } + return nil +} + +func (m *CMsgClientConnectionStats) GetStatsVconn() *CMsgClientConnectionStats_Stats_VConn { + if m != nil { + return m.StatsVconn + } + return nil +} + +type CMsgClientConnectionStats_Stats_Logon struct { + ConnectAttempts *int32 `protobuf:"varint,1,opt,name=connect_attempts" json:"connect_attempts,omitempty"` + ConnectSuccesses *int32 `protobuf:"varint,2,opt,name=connect_successes" json:"connect_successes,omitempty"` + ConnectFailures *int32 `protobuf:"varint,3,opt,name=connect_failures" json:"connect_failures,omitempty"` + ConnectionsDropped *int32 `protobuf:"varint,4,opt,name=connections_dropped" json:"connections_dropped,omitempty"` + SecondsRunning *uint32 `protobuf:"varint,5,opt,name=seconds_running" json:"seconds_running,omitempty"` + MsecTologonthistime *uint32 `protobuf:"varint,6,opt,name=msec_tologonthistime" json:"msec_tologonthistime,omitempty"` + CountBadCms *uint32 `protobuf:"varint,7,opt,name=count_bad_cms" json:"count_bad_cms,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientConnectionStats_Stats_Logon) Reset() { *m = CMsgClientConnectionStats_Stats_Logon{} } +func (m *CMsgClientConnectionStats_Stats_Logon) String() string { return proto.CompactTextString(m) } +func (*CMsgClientConnectionStats_Stats_Logon) ProtoMessage() {} +func (*CMsgClientConnectionStats_Stats_Logon) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{79, 0} +} + +func (m *CMsgClientConnectionStats_Stats_Logon) GetConnectAttempts() int32 { + if m != nil && m.ConnectAttempts != nil { + return *m.ConnectAttempts + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_Logon) GetConnectSuccesses() int32 { + if m != nil && m.ConnectSuccesses != nil { + return *m.ConnectSuccesses + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_Logon) GetConnectFailures() int32 { + if m != nil && m.ConnectFailures != nil { + return *m.ConnectFailures + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_Logon) GetConnectionsDropped() int32 { + if m != nil && m.ConnectionsDropped != nil { + return *m.ConnectionsDropped + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_Logon) GetSecondsRunning() uint32 { + if m != nil && m.SecondsRunning != nil { + return *m.SecondsRunning + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_Logon) GetMsecTologonthistime() uint32 { + if m != nil && m.MsecTologonthistime != nil { + return *m.MsecTologonthistime + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_Logon) GetCountBadCms() uint32 { + if m != nil && m.CountBadCms != nil { + return *m.CountBadCms + } + return 0 +} + +type CMsgClientConnectionStats_Stats_UDP struct { + PktsSent *uint64 `protobuf:"varint,1,opt,name=pkts_sent" json:"pkts_sent,omitempty"` + BytesSent *uint64 `protobuf:"varint,2,opt,name=bytes_sent" json:"bytes_sent,omitempty"` + PktsRecv *uint64 `protobuf:"varint,3,opt,name=pkts_recv" json:"pkts_recv,omitempty"` + PktsProcessed *uint64 `protobuf:"varint,4,opt,name=pkts_processed" json:"pkts_processed,omitempty"` + BytesRecv *uint64 `protobuf:"varint,5,opt,name=bytes_recv" json:"bytes_recv,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientConnectionStats_Stats_UDP) Reset() { *m = CMsgClientConnectionStats_Stats_UDP{} } +func (m *CMsgClientConnectionStats_Stats_UDP) String() string { return proto.CompactTextString(m) } +func (*CMsgClientConnectionStats_Stats_UDP) ProtoMessage() {} +func (*CMsgClientConnectionStats_Stats_UDP) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{79, 1} +} + +func (m *CMsgClientConnectionStats_Stats_UDP) GetPktsSent() uint64 { + if m != nil && m.PktsSent != nil { + return *m.PktsSent + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_UDP) GetBytesSent() uint64 { + if m != nil && m.BytesSent != nil { + return *m.BytesSent + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_UDP) GetPktsRecv() uint64 { + if m != nil && m.PktsRecv != nil { + return *m.PktsRecv + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_UDP) GetPktsProcessed() uint64 { + if m != nil && m.PktsProcessed != nil { + return *m.PktsProcessed + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_UDP) GetBytesRecv() uint64 { + if m != nil && m.BytesRecv != nil { + return *m.BytesRecv + } + return 0 +} + +type CMsgClientConnectionStats_Stats_VConn struct { + ConnectionsUdp *uint32 `protobuf:"varint,1,opt,name=connections_udp" json:"connections_udp,omitempty"` + ConnectionsTcp *uint32 `protobuf:"varint,2,opt,name=connections_tcp" json:"connections_tcp,omitempty"` + StatsUdp *CMsgClientConnectionStats_Stats_UDP `protobuf:"bytes,3,opt,name=stats_udp" json:"stats_udp,omitempty"` + PktsAbandoned *uint64 `protobuf:"varint,4,opt,name=pkts_abandoned" json:"pkts_abandoned,omitempty"` + ConnReqReceived *uint64 `protobuf:"varint,5,opt,name=conn_req_received" json:"conn_req_received,omitempty"` + PktsResent *uint64 `protobuf:"varint,6,opt,name=pkts_resent" json:"pkts_resent,omitempty"` + MsgsSent *uint64 `protobuf:"varint,7,opt,name=msgs_sent" json:"msgs_sent,omitempty"` + MsgsSentFailed *uint64 `protobuf:"varint,8,opt,name=msgs_sent_failed" json:"msgs_sent_failed,omitempty"` + MsgsRecv *uint64 `protobuf:"varint,9,opt,name=msgs_recv" json:"msgs_recv,omitempty"` + DatagramsSent *uint64 `protobuf:"varint,10,opt,name=datagrams_sent" json:"datagrams_sent,omitempty"` + DatagramsRecv *uint64 `protobuf:"varint,11,opt,name=datagrams_recv" json:"datagrams_recv,omitempty"` + BadPktsRecv *uint64 `protobuf:"varint,12,opt,name=bad_pkts_recv" json:"bad_pkts_recv,omitempty"` + UnknownConnPktsRecv *uint64 `protobuf:"varint,13,opt,name=unknown_conn_pkts_recv" json:"unknown_conn_pkts_recv,omitempty"` + MissedPktsRecv *uint64 `protobuf:"varint,14,opt,name=missed_pkts_recv" json:"missed_pkts_recv,omitempty"` + DupPktsRecv *uint64 `protobuf:"varint,15,opt,name=dup_pkts_recv" json:"dup_pkts_recv,omitempty"` + FailedConnectChallenges *uint64 `protobuf:"varint,16,opt,name=failed_connect_challenges" json:"failed_connect_challenges,omitempty"` + MicroSecAvgLatency *uint32 `protobuf:"varint,17,opt,name=micro_sec_avg_latency" json:"micro_sec_avg_latency,omitempty"` + MicroSecMinLatency *uint32 `protobuf:"varint,18,opt,name=micro_sec_min_latency" json:"micro_sec_min_latency,omitempty"` + MicroSecMaxLatency *uint32 `protobuf:"varint,19,opt,name=micro_sec_max_latency" json:"micro_sec_max_latency,omitempty"` + MemPoolMsgInUse *uint32 `protobuf:"varint,20,opt,name=mem_pool_msg_in_use" json:"mem_pool_msg_in_use,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientConnectionStats_Stats_VConn) Reset() { *m = CMsgClientConnectionStats_Stats_VConn{} } +func (m *CMsgClientConnectionStats_Stats_VConn) String() string { return proto.CompactTextString(m) } +func (*CMsgClientConnectionStats_Stats_VConn) ProtoMessage() {} +func (*CMsgClientConnectionStats_Stats_VConn) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{79, 2} +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetConnectionsUdp() uint32 { + if m != nil && m.ConnectionsUdp != nil { + return *m.ConnectionsUdp + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetConnectionsTcp() uint32 { + if m != nil && m.ConnectionsTcp != nil { + return *m.ConnectionsTcp + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetStatsUdp() *CMsgClientConnectionStats_Stats_UDP { + if m != nil { + return m.StatsUdp + } + return nil +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetPktsAbandoned() uint64 { + if m != nil && m.PktsAbandoned != nil { + return *m.PktsAbandoned + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetConnReqReceived() uint64 { + if m != nil && m.ConnReqReceived != nil { + return *m.ConnReqReceived + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetPktsResent() uint64 { + if m != nil && m.PktsResent != nil { + return *m.PktsResent + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMsgsSent() uint64 { + if m != nil && m.MsgsSent != nil { + return *m.MsgsSent + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMsgsSentFailed() uint64 { + if m != nil && m.MsgsSentFailed != nil { + return *m.MsgsSentFailed + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMsgsRecv() uint64 { + if m != nil && m.MsgsRecv != nil { + return *m.MsgsRecv + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetDatagramsSent() uint64 { + if m != nil && m.DatagramsSent != nil { + return *m.DatagramsSent + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetDatagramsRecv() uint64 { + if m != nil && m.DatagramsRecv != nil { + return *m.DatagramsRecv + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetBadPktsRecv() uint64 { + if m != nil && m.BadPktsRecv != nil { + return *m.BadPktsRecv + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetUnknownConnPktsRecv() uint64 { + if m != nil && m.UnknownConnPktsRecv != nil { + return *m.UnknownConnPktsRecv + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMissedPktsRecv() uint64 { + if m != nil && m.MissedPktsRecv != nil { + return *m.MissedPktsRecv + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetDupPktsRecv() uint64 { + if m != nil && m.DupPktsRecv != nil { + return *m.DupPktsRecv + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetFailedConnectChallenges() uint64 { + if m != nil && m.FailedConnectChallenges != nil { + return *m.FailedConnectChallenges + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMicroSecAvgLatency() uint32 { + if m != nil && m.MicroSecAvgLatency != nil { + return *m.MicroSecAvgLatency + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMicroSecMinLatency() uint32 { + if m != nil && m.MicroSecMinLatency != nil { + return *m.MicroSecMinLatency + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMicroSecMaxLatency() uint32 { + if m != nil && m.MicroSecMaxLatency != nil { + return *m.MicroSecMaxLatency + } + return 0 +} + +func (m *CMsgClientConnectionStats_Stats_VConn) GetMemPoolMsgInUse() uint32 { + if m != nil && m.MemPoolMsgInUse != nil { + return *m.MemPoolMsgInUse + } + return 0 +} + +type CMsgClientServersAvailable struct { + ServerTypesAvailable []*CMsgClientServersAvailable_Server_Types_Available `protobuf:"bytes,1,rep,name=server_types_available" json:"server_types_available,omitempty"` + ServerTypeForAuthServices *uint32 `protobuf:"varint,2,opt,name=server_type_for_auth_services" json:"server_type_for_auth_services,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServersAvailable) Reset() { *m = CMsgClientServersAvailable{} } +func (m *CMsgClientServersAvailable) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServersAvailable) ProtoMessage() {} +func (*CMsgClientServersAvailable) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{80} } + +func (m *CMsgClientServersAvailable) GetServerTypesAvailable() []*CMsgClientServersAvailable_Server_Types_Available { + if m != nil { + return m.ServerTypesAvailable + } + return nil +} + +func (m *CMsgClientServersAvailable) GetServerTypeForAuthServices() uint32 { + if m != nil && m.ServerTypeForAuthServices != nil { + return *m.ServerTypeForAuthServices + } + return 0 +} + +type CMsgClientServersAvailable_Server_Types_Available struct { + Server *uint32 `protobuf:"varint,1,opt,name=server" json:"server,omitempty"` + Changed *bool `protobuf:"varint,2,opt,name=changed" json:"changed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServersAvailable_Server_Types_Available) Reset() { + *m = CMsgClientServersAvailable_Server_Types_Available{} +} +func (m *CMsgClientServersAvailable_Server_Types_Available) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientServersAvailable_Server_Types_Available) ProtoMessage() {} +func (*CMsgClientServersAvailable_Server_Types_Available) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{80, 0} +} + +func (m *CMsgClientServersAvailable_Server_Types_Available) GetServer() uint32 { + if m != nil && m.Server != nil { + return *m.Server + } + return 0 +} + +func (m *CMsgClientServersAvailable_Server_Types_Available) GetChanged() bool { + if m != nil && m.Changed != nil { + return *m.Changed + } + return false +} + +type CMsgClientGetUserStats struct { + GameId *uint64 `protobuf:"fixed64,1,opt,name=game_id" json:"game_id,omitempty"` + CrcStats *uint32 `protobuf:"varint,2,opt,name=crc_stats" json:"crc_stats,omitempty"` + SchemaLocalVersion *int32 `protobuf:"varint,3,opt,name=schema_local_version" json:"schema_local_version,omitempty"` + SteamIdForUser *uint64 `protobuf:"fixed64,4,opt,name=steam_id_for_user" json:"steam_id_for_user,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetUserStats) Reset() { *m = CMsgClientGetUserStats{} } +func (m *CMsgClientGetUserStats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetUserStats) ProtoMessage() {} +func (*CMsgClientGetUserStats) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{81} } + +func (m *CMsgClientGetUserStats) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientGetUserStats) GetCrcStats() uint32 { + if m != nil && m.CrcStats != nil { + return *m.CrcStats + } + return 0 +} + +func (m *CMsgClientGetUserStats) GetSchemaLocalVersion() int32 { + if m != nil && m.SchemaLocalVersion != nil { + return *m.SchemaLocalVersion + } + return 0 +} + +func (m *CMsgClientGetUserStats) GetSteamIdForUser() uint64 { + if m != nil && m.SteamIdForUser != nil { + return *m.SteamIdForUser + } + return 0 +} + +type CMsgClientGetUserStatsResponse struct { + GameId *uint64 `protobuf:"fixed64,1,opt,name=game_id" json:"game_id,omitempty"` + Eresult *int32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + CrcStats *uint32 `protobuf:"varint,3,opt,name=crc_stats" json:"crc_stats,omitempty"` + Schema []byte `protobuf:"bytes,4,opt,name=schema" json:"schema,omitempty"` + Stats []*CMsgClientGetUserStatsResponse_Stats `protobuf:"bytes,5,rep,name=stats" json:"stats,omitempty"` + AchievementBlocks []*CMsgClientGetUserStatsResponse_Achievement_Blocks `protobuf:"bytes,6,rep,name=achievement_blocks" json:"achievement_blocks,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetUserStatsResponse) Reset() { *m = CMsgClientGetUserStatsResponse{} } +func (m *CMsgClientGetUserStatsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetUserStatsResponse) ProtoMessage() {} +func (*CMsgClientGetUserStatsResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{82} } + +const Default_CMsgClientGetUserStatsResponse_Eresult int32 = 2 + +func (m *CMsgClientGetUserStatsResponse) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientGetUserStatsResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientGetUserStatsResponse_Eresult +} + +func (m *CMsgClientGetUserStatsResponse) GetCrcStats() uint32 { + if m != nil && m.CrcStats != nil { + return *m.CrcStats + } + return 0 +} + +func (m *CMsgClientGetUserStatsResponse) GetSchema() []byte { + if m != nil { + return m.Schema + } + return nil +} + +func (m *CMsgClientGetUserStatsResponse) GetStats() []*CMsgClientGetUserStatsResponse_Stats { + if m != nil { + return m.Stats + } + return nil +} + +func (m *CMsgClientGetUserStatsResponse) GetAchievementBlocks() []*CMsgClientGetUserStatsResponse_Achievement_Blocks { + if m != nil { + return m.AchievementBlocks + } + return nil +} + +type CMsgClientGetUserStatsResponse_Stats struct { + StatId *uint32 `protobuf:"varint,1,opt,name=stat_id" json:"stat_id,omitempty"` + StatValue *uint32 `protobuf:"varint,2,opt,name=stat_value" json:"stat_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetUserStatsResponse_Stats) Reset() { *m = CMsgClientGetUserStatsResponse_Stats{} } +func (m *CMsgClientGetUserStatsResponse_Stats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetUserStatsResponse_Stats) ProtoMessage() {} +func (*CMsgClientGetUserStatsResponse_Stats) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{82, 0} +} + +func (m *CMsgClientGetUserStatsResponse_Stats) GetStatId() uint32 { + if m != nil && m.StatId != nil { + return *m.StatId + } + return 0 +} + +func (m *CMsgClientGetUserStatsResponse_Stats) GetStatValue() uint32 { + if m != nil && m.StatValue != nil { + return *m.StatValue + } + return 0 +} + +type CMsgClientGetUserStatsResponse_Achievement_Blocks struct { + AchievementId *uint32 `protobuf:"varint,1,opt,name=achievement_id" json:"achievement_id,omitempty"` + UnlockTime []uint32 `protobuf:"fixed32,2,rep,name=unlock_time" json:"unlock_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetUserStatsResponse_Achievement_Blocks) Reset() { + *m = CMsgClientGetUserStatsResponse_Achievement_Blocks{} +} +func (m *CMsgClientGetUserStatsResponse_Achievement_Blocks) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientGetUserStatsResponse_Achievement_Blocks) ProtoMessage() {} +func (*CMsgClientGetUserStatsResponse_Achievement_Blocks) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{82, 1} +} + +func (m *CMsgClientGetUserStatsResponse_Achievement_Blocks) GetAchievementId() uint32 { + if m != nil && m.AchievementId != nil { + return *m.AchievementId + } + return 0 +} + +func (m *CMsgClientGetUserStatsResponse_Achievement_Blocks) GetUnlockTime() []uint32 { + if m != nil { + return m.UnlockTime + } + return nil +} + +type CMsgClientStoreUserStatsResponse struct { + GameId *uint64 `protobuf:"fixed64,1,opt,name=game_id" json:"game_id,omitempty"` + Eresult *int32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + CrcStats *uint32 `protobuf:"varint,3,opt,name=crc_stats" json:"crc_stats,omitempty"` + StatsFailedValidation []*CMsgClientStoreUserStatsResponse_Stats_Failed_Validation `protobuf:"bytes,4,rep,name=stats_failed_validation" json:"stats_failed_validation,omitempty"` + StatsOutOfDate *bool `protobuf:"varint,5,opt,name=stats_out_of_date" json:"stats_out_of_date,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStoreUserStatsResponse) Reset() { *m = CMsgClientStoreUserStatsResponse{} } +func (m *CMsgClientStoreUserStatsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStoreUserStatsResponse) ProtoMessage() {} +func (*CMsgClientStoreUserStatsResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{83} +} + +const Default_CMsgClientStoreUserStatsResponse_Eresult int32 = 2 + +func (m *CMsgClientStoreUserStatsResponse) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientStoreUserStatsResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientStoreUserStatsResponse_Eresult +} + +func (m *CMsgClientStoreUserStatsResponse) GetCrcStats() uint32 { + if m != nil && m.CrcStats != nil { + return *m.CrcStats + } + return 0 +} + +func (m *CMsgClientStoreUserStatsResponse) GetStatsFailedValidation() []*CMsgClientStoreUserStatsResponse_Stats_Failed_Validation { + if m != nil { + return m.StatsFailedValidation + } + return nil +} + +func (m *CMsgClientStoreUserStatsResponse) GetStatsOutOfDate() bool { + if m != nil && m.StatsOutOfDate != nil { + return *m.StatsOutOfDate + } + return false +} + +type CMsgClientStoreUserStatsResponse_Stats_Failed_Validation struct { + StatId *uint32 `protobuf:"varint,1,opt,name=stat_id" json:"stat_id,omitempty"` + RevertedStatValue *uint32 `protobuf:"varint,2,opt,name=reverted_stat_value" json:"reverted_stat_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStoreUserStatsResponse_Stats_Failed_Validation) Reset() { + *m = CMsgClientStoreUserStatsResponse_Stats_Failed_Validation{} +} +func (m *CMsgClientStoreUserStatsResponse_Stats_Failed_Validation) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientStoreUserStatsResponse_Stats_Failed_Validation) ProtoMessage() {} +func (*CMsgClientStoreUserStatsResponse_Stats_Failed_Validation) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{83, 0} +} + +func (m *CMsgClientStoreUserStatsResponse_Stats_Failed_Validation) GetStatId() uint32 { + if m != nil && m.StatId != nil { + return *m.StatId + } + return 0 +} + +func (m *CMsgClientStoreUserStatsResponse_Stats_Failed_Validation) GetRevertedStatValue() uint32 { + if m != nil && m.RevertedStatValue != nil { + return *m.RevertedStatValue + } + return 0 +} + +type CMsgClientStoreUserStats2 struct { + GameId *uint64 `protobuf:"fixed64,1,opt,name=game_id" json:"game_id,omitempty"` + SettorSteamId *uint64 `protobuf:"fixed64,2,opt,name=settor_steam_id" json:"settor_steam_id,omitempty"` + SetteeSteamId *uint64 `protobuf:"fixed64,3,opt,name=settee_steam_id" json:"settee_steam_id,omitempty"` + CrcStats *uint32 `protobuf:"varint,4,opt,name=crc_stats" json:"crc_stats,omitempty"` + ExplicitReset *bool `protobuf:"varint,5,opt,name=explicit_reset" json:"explicit_reset,omitempty"` + Stats []*CMsgClientStoreUserStats2_Stats `protobuf:"bytes,6,rep,name=stats" json:"stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStoreUserStats2) Reset() { *m = CMsgClientStoreUserStats2{} } +func (m *CMsgClientStoreUserStats2) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStoreUserStats2) ProtoMessage() {} +func (*CMsgClientStoreUserStats2) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{84} } + +func (m *CMsgClientStoreUserStats2) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientStoreUserStats2) GetSettorSteamId() uint64 { + if m != nil && m.SettorSteamId != nil { + return *m.SettorSteamId + } + return 0 +} + +func (m *CMsgClientStoreUserStats2) GetSetteeSteamId() uint64 { + if m != nil && m.SetteeSteamId != nil { + return *m.SetteeSteamId + } + return 0 +} + +func (m *CMsgClientStoreUserStats2) GetCrcStats() uint32 { + if m != nil && m.CrcStats != nil { + return *m.CrcStats + } + return 0 +} + +func (m *CMsgClientStoreUserStats2) GetExplicitReset() bool { + if m != nil && m.ExplicitReset != nil { + return *m.ExplicitReset + } + return false +} + +func (m *CMsgClientStoreUserStats2) GetStats() []*CMsgClientStoreUserStats2_Stats { + if m != nil { + return m.Stats + } + return nil +} + +type CMsgClientStoreUserStats2_Stats struct { + StatId *uint32 `protobuf:"varint,1,opt,name=stat_id" json:"stat_id,omitempty"` + StatValue *uint32 `protobuf:"varint,2,opt,name=stat_value" json:"stat_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStoreUserStats2_Stats) Reset() { *m = CMsgClientStoreUserStats2_Stats{} } +func (m *CMsgClientStoreUserStats2_Stats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStoreUserStats2_Stats) ProtoMessage() {} +func (*CMsgClientStoreUserStats2_Stats) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{84, 0} +} + +func (m *CMsgClientStoreUserStats2_Stats) GetStatId() uint32 { + if m != nil && m.StatId != nil { + return *m.StatId + } + return 0 +} + +func (m *CMsgClientStoreUserStats2_Stats) GetStatValue() uint32 { + if m != nil && m.StatValue != nil { + return *m.StatValue + } + return 0 +} + +type CMsgClientStatsUpdated struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + GameId *uint64 `protobuf:"fixed64,2,opt,name=game_id" json:"game_id,omitempty"` + CrcStats *uint32 `protobuf:"varint,3,opt,name=crc_stats" json:"crc_stats,omitempty"` + UpdatedStats []*CMsgClientStatsUpdated_Updated_Stats `protobuf:"bytes,4,rep,name=updated_stats" json:"updated_stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStatsUpdated) Reset() { *m = CMsgClientStatsUpdated{} } +func (m *CMsgClientStatsUpdated) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStatsUpdated) ProtoMessage() {} +func (*CMsgClientStatsUpdated) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{85} } + +func (m *CMsgClientStatsUpdated) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgClientStatsUpdated) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientStatsUpdated) GetCrcStats() uint32 { + if m != nil && m.CrcStats != nil { + return *m.CrcStats + } + return 0 +} + +func (m *CMsgClientStatsUpdated) GetUpdatedStats() []*CMsgClientStatsUpdated_Updated_Stats { + if m != nil { + return m.UpdatedStats + } + return nil +} + +type CMsgClientStatsUpdated_Updated_Stats struct { + StatId *uint32 `protobuf:"varint,1,opt,name=stat_id" json:"stat_id,omitempty"` + StatValue *uint32 `protobuf:"varint,2,opt,name=stat_value" json:"stat_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStatsUpdated_Updated_Stats) Reset() { *m = CMsgClientStatsUpdated_Updated_Stats{} } +func (m *CMsgClientStatsUpdated_Updated_Stats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStatsUpdated_Updated_Stats) ProtoMessage() {} +func (*CMsgClientStatsUpdated_Updated_Stats) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{85, 0} +} + +func (m *CMsgClientStatsUpdated_Updated_Stats) GetStatId() uint32 { + if m != nil && m.StatId != nil { + return *m.StatId + } + return 0 +} + +func (m *CMsgClientStatsUpdated_Updated_Stats) GetStatValue() uint32 { + if m != nil && m.StatValue != nil { + return *m.StatValue + } + return 0 +} + +type CMsgClientStoreUserStats struct { + GameId *uint64 `protobuf:"fixed64,1,opt,name=game_id" json:"game_id,omitempty"` + ExplicitReset *bool `protobuf:"varint,2,opt,name=explicit_reset" json:"explicit_reset,omitempty"` + StatsToStore []*CMsgClientStoreUserStats_Stats_To_Store `protobuf:"bytes,3,rep,name=stats_to_store" json:"stats_to_store,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStoreUserStats) Reset() { *m = CMsgClientStoreUserStats{} } +func (m *CMsgClientStoreUserStats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStoreUserStats) ProtoMessage() {} +func (*CMsgClientStoreUserStats) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{86} } + +func (m *CMsgClientStoreUserStats) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientStoreUserStats) GetExplicitReset() bool { + if m != nil && m.ExplicitReset != nil { + return *m.ExplicitReset + } + return false +} + +func (m *CMsgClientStoreUserStats) GetStatsToStore() []*CMsgClientStoreUserStats_Stats_To_Store { + if m != nil { + return m.StatsToStore + } + return nil +} + +type CMsgClientStoreUserStats_Stats_To_Store struct { + StatId *uint32 `protobuf:"varint,1,opt,name=stat_id" json:"stat_id,omitempty"` + StatValue *uint32 `protobuf:"varint,2,opt,name=stat_value" json:"stat_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientStoreUserStats_Stats_To_Store) Reset() { + *m = CMsgClientStoreUserStats_Stats_To_Store{} +} +func (m *CMsgClientStoreUserStats_Stats_To_Store) String() string { return proto.CompactTextString(m) } +func (*CMsgClientStoreUserStats_Stats_To_Store) ProtoMessage() {} +func (*CMsgClientStoreUserStats_Stats_To_Store) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{86, 0} +} + +func (m *CMsgClientStoreUserStats_Stats_To_Store) GetStatId() uint32 { + if m != nil && m.StatId != nil { + return *m.StatId + } + return 0 +} + +func (m *CMsgClientStoreUserStats_Stats_To_Store) GetStatValue() uint32 { + if m != nil && m.StatValue != nil { + return *m.StatValue + } + return 0 +} + +type CMsgClientGetClientDetails struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClientDetails) Reset() { *m = CMsgClientGetClientDetails{} } +func (m *CMsgClientGetClientDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClientDetails) ProtoMessage() {} +func (*CMsgClientGetClientDetails) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{87} } + +type CMsgClientReportOverlayDetourFailure struct { + FailureStrings []string `protobuf:"bytes,1,rep,name=failure_strings" json:"failure_strings,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientReportOverlayDetourFailure) Reset() { *m = CMsgClientReportOverlayDetourFailure{} } +func (m *CMsgClientReportOverlayDetourFailure) String() string { return proto.CompactTextString(m) } +func (*CMsgClientReportOverlayDetourFailure) ProtoMessage() {} +func (*CMsgClientReportOverlayDetourFailure) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{88} +} + +func (m *CMsgClientReportOverlayDetourFailure) GetFailureStrings() []string { + if m != nil { + return m.FailureStrings + } + return nil +} + +type CMsgClientGetClientDetailsResponse struct { + PackageVersion *uint32 `protobuf:"varint,1,opt,name=package_version" json:"package_version,omitempty"` + ProtocolVersion *uint32 `protobuf:"varint,8,opt,name=protocol_version" json:"protocol_version,omitempty"` + Os *string `protobuf:"bytes,2,opt,name=os" json:"os,omitempty"` + MachineName *string `protobuf:"bytes,3,opt,name=machine_name" json:"machine_name,omitempty"` + IpPublic *string `protobuf:"bytes,4,opt,name=ip_public" json:"ip_public,omitempty"` + IpPrivate *string `protobuf:"bytes,5,opt,name=ip_private" json:"ip_private,omitempty"` + BytesAvailable *uint64 `protobuf:"varint,7,opt,name=bytes_available" json:"bytes_available,omitempty"` + GamesRunning []*CMsgClientGetClientDetailsResponse_Game `protobuf:"bytes,6,rep,name=games_running" json:"games_running,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClientDetailsResponse) Reset() { *m = CMsgClientGetClientDetailsResponse{} } +func (m *CMsgClientGetClientDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClientDetailsResponse) ProtoMessage() {} +func (*CMsgClientGetClientDetailsResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{89} +} + +func (m *CMsgClientGetClientDetailsResponse) GetPackageVersion() uint32 { + if m != nil && m.PackageVersion != nil { + return *m.PackageVersion + } + return 0 +} + +func (m *CMsgClientGetClientDetailsResponse) GetProtocolVersion() uint32 { + if m != nil && m.ProtocolVersion != nil { + return *m.ProtocolVersion + } + return 0 +} + +func (m *CMsgClientGetClientDetailsResponse) GetOs() string { + if m != nil && m.Os != nil { + return *m.Os + } + return "" +} + +func (m *CMsgClientGetClientDetailsResponse) GetMachineName() string { + if m != nil && m.MachineName != nil { + return *m.MachineName + } + return "" +} + +func (m *CMsgClientGetClientDetailsResponse) GetIpPublic() string { + if m != nil && m.IpPublic != nil { + return *m.IpPublic + } + return "" +} + +func (m *CMsgClientGetClientDetailsResponse) GetIpPrivate() string { + if m != nil && m.IpPrivate != nil { + return *m.IpPrivate + } + return "" +} + +func (m *CMsgClientGetClientDetailsResponse) GetBytesAvailable() uint64 { + if m != nil && m.BytesAvailable != nil { + return *m.BytesAvailable + } + return 0 +} + +func (m *CMsgClientGetClientDetailsResponse) GetGamesRunning() []*CMsgClientGetClientDetailsResponse_Game { + if m != nil { + return m.GamesRunning + } + return nil +} + +type CMsgClientGetClientDetailsResponse_Game struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + ExtraInfo *string `protobuf:"bytes,2,opt,name=extra_info" json:"extra_info,omitempty"` + TimeRunningSec *uint32 `protobuf:"varint,3,opt,name=time_running_sec" json:"time_running_sec,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClientDetailsResponse_Game) Reset() { + *m = CMsgClientGetClientDetailsResponse_Game{} +} +func (m *CMsgClientGetClientDetailsResponse_Game) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClientDetailsResponse_Game) ProtoMessage() {} +func (*CMsgClientGetClientDetailsResponse_Game) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{89, 0} +} + +func (m *CMsgClientGetClientDetailsResponse_Game) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientGetClientDetailsResponse_Game) GetExtraInfo() string { + if m != nil && m.ExtraInfo != nil { + return *m.ExtraInfo + } + return "" +} + +func (m *CMsgClientGetClientDetailsResponse_Game) GetTimeRunningSec() uint32 { + if m != nil && m.TimeRunningSec != nil { + return *m.TimeRunningSec + } + return 0 +} + +type CMsgClientGetClientAppList struct { + Media *bool `protobuf:"varint,1,opt,name=media" json:"media,omitempty"` + Tools *bool `protobuf:"varint,2,opt,name=tools" json:"tools,omitempty"` + Games *bool `protobuf:"varint,3,opt,name=games" json:"games,omitempty"` + OnlyInstalled *bool `protobuf:"varint,4,opt,name=only_installed" json:"only_installed,omitempty"` + OnlyChanging *bool `protobuf:"varint,5,opt,name=only_changing" json:"only_changing,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClientAppList) Reset() { *m = CMsgClientGetClientAppList{} } +func (m *CMsgClientGetClientAppList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClientAppList) ProtoMessage() {} +func (*CMsgClientGetClientAppList) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{90} } + +func (m *CMsgClientGetClientAppList) GetMedia() bool { + if m != nil && m.Media != nil { + return *m.Media + } + return false +} + +func (m *CMsgClientGetClientAppList) GetTools() bool { + if m != nil && m.Tools != nil { + return *m.Tools + } + return false +} + +func (m *CMsgClientGetClientAppList) GetGames() bool { + if m != nil && m.Games != nil { + return *m.Games + } + return false +} + +func (m *CMsgClientGetClientAppList) GetOnlyInstalled() bool { + if m != nil && m.OnlyInstalled != nil { + return *m.OnlyInstalled + } + return false +} + +func (m *CMsgClientGetClientAppList) GetOnlyChanging() bool { + if m != nil && m.OnlyChanging != nil { + return *m.OnlyChanging + } + return false +} + +type CMsgClientGetClientAppListResponse struct { + Apps []*CMsgClientGetClientAppListResponse_App `protobuf:"bytes,1,rep,name=apps" json:"apps,omitempty"` + BytesAvailable *uint64 `protobuf:"varint,2,opt,name=bytes_available" json:"bytes_available,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClientAppListResponse) Reset() { *m = CMsgClientGetClientAppListResponse{} } +func (m *CMsgClientGetClientAppListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClientAppListResponse) ProtoMessage() {} +func (*CMsgClientGetClientAppListResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{91} +} + +func (m *CMsgClientGetClientAppListResponse) GetApps() []*CMsgClientGetClientAppListResponse_App { + if m != nil { + return m.Apps + } + return nil +} + +func (m *CMsgClientGetClientAppListResponse) GetBytesAvailable() uint64 { + if m != nil && m.BytesAvailable != nil { + return *m.BytesAvailable + } + return 0 +} + +type CMsgClientGetClientAppListResponse_App struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Category *string `protobuf:"bytes,2,opt,name=category" json:"category,omitempty"` + AppType *string `protobuf:"bytes,10,opt,name=app_type" json:"app_type,omitempty"` + Favorite *bool `protobuf:"varint,3,opt,name=favorite" json:"favorite,omitempty"` + Installed *bool `protobuf:"varint,4,opt,name=installed" json:"installed,omitempty"` + AutoUpdate *bool `protobuf:"varint,5,opt,name=auto_update" json:"auto_update,omitempty"` + BytesDownloaded *uint64 `protobuf:"varint,6,opt,name=bytes_downloaded" json:"bytes_downloaded,omitempty"` + BytesNeeded *uint64 `protobuf:"varint,7,opt,name=bytes_needed" json:"bytes_needed,omitempty"` + BytesDownloadRate *uint32 `protobuf:"varint,8,opt,name=bytes_download_rate" json:"bytes_download_rate,omitempty"` + DownloadPaused *bool `protobuf:"varint,11,opt,name=download_paused" json:"download_paused,omitempty"` + NumDownloading *uint32 `protobuf:"varint,12,opt,name=num_downloading" json:"num_downloading,omitempty"` + NumPaused *uint32 `protobuf:"varint,13,opt,name=num_paused" json:"num_paused,omitempty"` + Changing *bool `protobuf:"varint,14,opt,name=changing" json:"changing,omitempty"` + AvailableOnPlatform *bool `protobuf:"varint,15,opt,name=available_on_platform" json:"available_on_platform,omitempty"` + Dlcs []*CMsgClientGetClientAppListResponse_App_DLC `protobuf:"bytes,9,rep,name=dlcs" json:"dlcs,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClientAppListResponse_App) Reset() { + *m = CMsgClientGetClientAppListResponse_App{} +} +func (m *CMsgClientGetClientAppListResponse_App) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClientAppListResponse_App) ProtoMessage() {} +func (*CMsgClientGetClientAppListResponse_App) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{91, 0} +} + +func (m *CMsgClientGetClientAppListResponse_App) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientGetClientAppListResponse_App) GetCategory() string { + if m != nil && m.Category != nil { + return *m.Category + } + return "" +} + +func (m *CMsgClientGetClientAppListResponse_App) GetAppType() string { + if m != nil && m.AppType != nil { + return *m.AppType + } + return "" +} + +func (m *CMsgClientGetClientAppListResponse_App) GetFavorite() bool { + if m != nil && m.Favorite != nil { + return *m.Favorite + } + return false +} + +func (m *CMsgClientGetClientAppListResponse_App) GetInstalled() bool { + if m != nil && m.Installed != nil { + return *m.Installed + } + return false +} + +func (m *CMsgClientGetClientAppListResponse_App) GetAutoUpdate() bool { + if m != nil && m.AutoUpdate != nil { + return *m.AutoUpdate + } + return false +} + +func (m *CMsgClientGetClientAppListResponse_App) GetBytesDownloaded() uint64 { + if m != nil && m.BytesDownloaded != nil { + return *m.BytesDownloaded + } + return 0 +} + +func (m *CMsgClientGetClientAppListResponse_App) GetBytesNeeded() uint64 { + if m != nil && m.BytesNeeded != nil { + return *m.BytesNeeded + } + return 0 +} + +func (m *CMsgClientGetClientAppListResponse_App) GetBytesDownloadRate() uint32 { + if m != nil && m.BytesDownloadRate != nil { + return *m.BytesDownloadRate + } + return 0 +} + +func (m *CMsgClientGetClientAppListResponse_App) GetDownloadPaused() bool { + if m != nil && m.DownloadPaused != nil { + return *m.DownloadPaused + } + return false +} + +func (m *CMsgClientGetClientAppListResponse_App) GetNumDownloading() uint32 { + if m != nil && m.NumDownloading != nil { + return *m.NumDownloading + } + return 0 +} + +func (m *CMsgClientGetClientAppListResponse_App) GetNumPaused() uint32 { + if m != nil && m.NumPaused != nil { + return *m.NumPaused + } + return 0 +} + +func (m *CMsgClientGetClientAppListResponse_App) GetChanging() bool { + if m != nil && m.Changing != nil { + return *m.Changing + } + return false +} + +func (m *CMsgClientGetClientAppListResponse_App) GetAvailableOnPlatform() bool { + if m != nil && m.AvailableOnPlatform != nil { + return *m.AvailableOnPlatform + } + return false +} + +func (m *CMsgClientGetClientAppListResponse_App) GetDlcs() []*CMsgClientGetClientAppListResponse_App_DLC { + if m != nil { + return m.Dlcs + } + return nil +} + +type CMsgClientGetClientAppListResponse_App_DLC struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Installed *bool `protobuf:"varint,2,opt,name=installed" json:"installed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClientAppListResponse_App_DLC) Reset() { + *m = CMsgClientGetClientAppListResponse_App_DLC{} +} +func (m *CMsgClientGetClientAppListResponse_App_DLC) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientGetClientAppListResponse_App_DLC) ProtoMessage() {} +func (*CMsgClientGetClientAppListResponse_App_DLC) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{91, 0, 0} +} + +func (m *CMsgClientGetClientAppListResponse_App_DLC) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientGetClientAppListResponse_App_DLC) GetInstalled() bool { + if m != nil && m.Installed != nil { + return *m.Installed + } + return false +} + +type CMsgClientInstallClientApp struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientInstallClientApp) Reset() { *m = CMsgClientInstallClientApp{} } +func (m *CMsgClientInstallClientApp) String() string { return proto.CompactTextString(m) } +func (*CMsgClientInstallClientApp) ProtoMessage() {} +func (*CMsgClientInstallClientApp) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{92} } + +func (m *CMsgClientInstallClientApp) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CMsgClientInstallClientAppResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientInstallClientAppResponse) Reset() { *m = CMsgClientInstallClientAppResponse{} } +func (m *CMsgClientInstallClientAppResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientInstallClientAppResponse) ProtoMessage() {} +func (*CMsgClientInstallClientAppResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{93} +} + +func (m *CMsgClientInstallClientAppResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgClientUninstallClientApp struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUninstallClientApp) Reset() { *m = CMsgClientUninstallClientApp{} } +func (m *CMsgClientUninstallClientApp) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUninstallClientApp) ProtoMessage() {} +func (*CMsgClientUninstallClientApp) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{94} } + +func (m *CMsgClientUninstallClientApp) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CMsgClientUninstallClientAppResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUninstallClientAppResponse) Reset() { *m = CMsgClientUninstallClientAppResponse{} } +func (m *CMsgClientUninstallClientAppResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUninstallClientAppResponse) ProtoMessage() {} +func (*CMsgClientUninstallClientAppResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{95} +} + +func (m *CMsgClientUninstallClientAppResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgClientSetClientAppUpdateState struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Update *bool `protobuf:"varint,2,opt,name=update" json:"update,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSetClientAppUpdateState) Reset() { *m = CMsgClientSetClientAppUpdateState{} } +func (m *CMsgClientSetClientAppUpdateState) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSetClientAppUpdateState) ProtoMessage() {} +func (*CMsgClientSetClientAppUpdateState) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{96} +} + +func (m *CMsgClientSetClientAppUpdateState) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientSetClientAppUpdateState) GetUpdate() bool { + if m != nil && m.Update != nil { + return *m.Update + } + return false +} + +type CMsgClientSetClientAppUpdateStateResponse struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSetClientAppUpdateStateResponse) Reset() { + *m = CMsgClientSetClientAppUpdateStateResponse{} +} +func (m *CMsgClientSetClientAppUpdateStateResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSetClientAppUpdateStateResponse) ProtoMessage() {} +func (*CMsgClientSetClientAppUpdateStateResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{97} +} + +func (m *CMsgClientSetClientAppUpdateStateResponse) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +type CMsgClientUFSUploadFileRequest struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + FileSize *uint32 `protobuf:"varint,2,opt,name=file_size" json:"file_size,omitempty"` + RawFileSize *uint32 `protobuf:"varint,3,opt,name=raw_file_size" json:"raw_file_size,omitempty"` + ShaFile []byte `protobuf:"bytes,4,opt,name=sha_file" json:"sha_file,omitempty"` + TimeStamp *uint64 `protobuf:"varint,5,opt,name=time_stamp" json:"time_stamp,omitempty"` + FileName *string `protobuf:"bytes,6,opt,name=file_name" json:"file_name,omitempty"` + PlatformsToSyncDeprecated *uint32 `protobuf:"varint,7,opt,name=platforms_to_sync_deprecated" json:"platforms_to_sync_deprecated,omitempty"` + PlatformsToSync *uint32 `protobuf:"varint,8,opt,name=platforms_to_sync,def=4294967295" json:"platforms_to_sync,omitempty"` + CellId *uint32 `protobuf:"varint,9,opt,name=cell_id" json:"cell_id,omitempty"` + CanEncrypt *bool `protobuf:"varint,10,opt,name=can_encrypt" json:"can_encrypt,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSUploadFileRequest) Reset() { *m = CMsgClientUFSUploadFileRequest{} } +func (m *CMsgClientUFSUploadFileRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSUploadFileRequest) ProtoMessage() {} +func (*CMsgClientUFSUploadFileRequest) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{98} } + +const Default_CMsgClientUFSUploadFileRequest_PlatformsToSync uint32 = 4294967295 + +func (m *CMsgClientUFSUploadFileRequest) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSUploadFileRequest) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CMsgClientUFSUploadFileRequest) GetRawFileSize() uint32 { + if m != nil && m.RawFileSize != nil { + return *m.RawFileSize + } + return 0 +} + +func (m *CMsgClientUFSUploadFileRequest) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUFSUploadFileRequest) GetTimeStamp() uint64 { + if m != nil && m.TimeStamp != nil { + return *m.TimeStamp + } + return 0 +} + +func (m *CMsgClientUFSUploadFileRequest) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +func (m *CMsgClientUFSUploadFileRequest) GetPlatformsToSyncDeprecated() uint32 { + if m != nil && m.PlatformsToSyncDeprecated != nil { + return *m.PlatformsToSyncDeprecated + } + return 0 +} + +func (m *CMsgClientUFSUploadFileRequest) GetPlatformsToSync() uint32 { + if m != nil && m.PlatformsToSync != nil { + return *m.PlatformsToSync + } + return Default_CMsgClientUFSUploadFileRequest_PlatformsToSync +} + +func (m *CMsgClientUFSUploadFileRequest) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CMsgClientUFSUploadFileRequest) GetCanEncrypt() bool { + if m != nil && m.CanEncrypt != nil { + return *m.CanEncrypt + } + return false +} + +type CMsgClientUFSUploadFileResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + ShaFile []byte `protobuf:"bytes,2,opt,name=sha_file" json:"sha_file,omitempty"` + UseHttp *bool `protobuf:"varint,3,opt,name=use_http" json:"use_http,omitempty"` + HttpHost *string `protobuf:"bytes,4,opt,name=http_host" json:"http_host,omitempty"` + HttpUrl *string `protobuf:"bytes,5,opt,name=http_url" json:"http_url,omitempty"` + KvHeaders []byte `protobuf:"bytes,6,opt,name=kv_headers" json:"kv_headers,omitempty"` + UseHttps *bool `protobuf:"varint,7,opt,name=use_https" json:"use_https,omitempty"` + EncryptFile *bool `protobuf:"varint,8,opt,name=encrypt_file" json:"encrypt_file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSUploadFileResponse) Reset() { *m = CMsgClientUFSUploadFileResponse{} } +func (m *CMsgClientUFSUploadFileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSUploadFileResponse) ProtoMessage() {} +func (*CMsgClientUFSUploadFileResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{99} +} + +const Default_CMsgClientUFSUploadFileResponse_Eresult int32 = 2 + +func (m *CMsgClientUFSUploadFileResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSUploadFileResponse_Eresult +} + +func (m *CMsgClientUFSUploadFileResponse) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUFSUploadFileResponse) GetUseHttp() bool { + if m != nil && m.UseHttp != nil { + return *m.UseHttp + } + return false +} + +func (m *CMsgClientUFSUploadFileResponse) GetHttpHost() string { + if m != nil && m.HttpHost != nil { + return *m.HttpHost + } + return "" +} + +func (m *CMsgClientUFSUploadFileResponse) GetHttpUrl() string { + if m != nil && m.HttpUrl != nil { + return *m.HttpUrl + } + return "" +} + +func (m *CMsgClientUFSUploadFileResponse) GetKvHeaders() []byte { + if m != nil { + return m.KvHeaders + } + return nil +} + +func (m *CMsgClientUFSUploadFileResponse) GetUseHttps() bool { + if m != nil && m.UseHttps != nil { + return *m.UseHttps + } + return false +} + +func (m *CMsgClientUFSUploadFileResponse) GetEncryptFile() bool { + if m != nil && m.EncryptFile != nil { + return *m.EncryptFile + } + return false +} + +type CMsgClientUFSUploadCommit struct { + Files []*CMsgClientUFSUploadCommit_File `protobuf:"bytes,1,rep,name=files" json:"files,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSUploadCommit) Reset() { *m = CMsgClientUFSUploadCommit{} } +func (m *CMsgClientUFSUploadCommit) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSUploadCommit) ProtoMessage() {} +func (*CMsgClientUFSUploadCommit) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{100} } + +func (m *CMsgClientUFSUploadCommit) GetFiles() []*CMsgClientUFSUploadCommit_File { + if m != nil { + return m.Files + } + return nil +} + +type CMsgClientUFSUploadCommit_File struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + ShaFile []byte `protobuf:"bytes,3,opt,name=sha_file" json:"sha_file,omitempty"` + CubFile *uint32 `protobuf:"varint,4,opt,name=cub_file" json:"cub_file,omitempty"` + FileName *string `protobuf:"bytes,5,opt,name=file_name" json:"file_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSUploadCommit_File) Reset() { *m = CMsgClientUFSUploadCommit_File{} } +func (m *CMsgClientUFSUploadCommit_File) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSUploadCommit_File) ProtoMessage() {} +func (*CMsgClientUFSUploadCommit_File) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{100, 0} +} + +const Default_CMsgClientUFSUploadCommit_File_Eresult int32 = 2 + +func (m *CMsgClientUFSUploadCommit_File) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSUploadCommit_File_Eresult +} + +func (m *CMsgClientUFSUploadCommit_File) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSUploadCommit_File) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUFSUploadCommit_File) GetCubFile() uint32 { + if m != nil && m.CubFile != nil { + return *m.CubFile + } + return 0 +} + +func (m *CMsgClientUFSUploadCommit_File) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +type CMsgClientUFSUploadCommitResponse struct { + Files []*CMsgClientUFSUploadCommitResponse_File `protobuf:"bytes,1,rep,name=files" json:"files,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSUploadCommitResponse) Reset() { *m = CMsgClientUFSUploadCommitResponse{} } +func (m *CMsgClientUFSUploadCommitResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSUploadCommitResponse) ProtoMessage() {} +func (*CMsgClientUFSUploadCommitResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{101} +} + +func (m *CMsgClientUFSUploadCommitResponse) GetFiles() []*CMsgClientUFSUploadCommitResponse_File { + if m != nil { + return m.Files + } + return nil +} + +type CMsgClientUFSUploadCommitResponse_File struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + ShaFile []byte `protobuf:"bytes,3,opt,name=sha_file" json:"sha_file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSUploadCommitResponse_File) Reset() { + *m = CMsgClientUFSUploadCommitResponse_File{} +} +func (m *CMsgClientUFSUploadCommitResponse_File) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSUploadCommitResponse_File) ProtoMessage() {} +func (*CMsgClientUFSUploadCommitResponse_File) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{101, 0} +} + +const Default_CMsgClientUFSUploadCommitResponse_File_Eresult int32 = 2 + +func (m *CMsgClientUFSUploadCommitResponse_File) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSUploadCommitResponse_File_Eresult +} + +func (m *CMsgClientUFSUploadCommitResponse_File) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSUploadCommitResponse_File) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +type CMsgClientUFSFileChunk struct { + ShaFile []byte `protobuf:"bytes,1,opt,name=sha_file" json:"sha_file,omitempty"` + FileStart *uint32 `protobuf:"varint,2,opt,name=file_start" json:"file_start,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSFileChunk) Reset() { *m = CMsgClientUFSFileChunk{} } +func (m *CMsgClientUFSFileChunk) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSFileChunk) ProtoMessage() {} +func (*CMsgClientUFSFileChunk) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{102} } + +func (m *CMsgClientUFSFileChunk) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUFSFileChunk) GetFileStart() uint32 { + if m != nil && m.FileStart != nil { + return *m.FileStart + } + return 0 +} + +func (m *CMsgClientUFSFileChunk) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +type CMsgClientUFSTransferHeartbeat struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSTransferHeartbeat) Reset() { *m = CMsgClientUFSTransferHeartbeat{} } +func (m *CMsgClientUFSTransferHeartbeat) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSTransferHeartbeat) ProtoMessage() {} +func (*CMsgClientUFSTransferHeartbeat) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{103} +} + +type CMsgClientUFSUploadFileFinished struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + ShaFile []byte `protobuf:"bytes,2,opt,name=sha_file" json:"sha_file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSUploadFileFinished) Reset() { *m = CMsgClientUFSUploadFileFinished{} } +func (m *CMsgClientUFSUploadFileFinished) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSUploadFileFinished) ProtoMessage() {} +func (*CMsgClientUFSUploadFileFinished) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{104} +} + +const Default_CMsgClientUFSUploadFileFinished_Eresult int32 = 2 + +func (m *CMsgClientUFSUploadFileFinished) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSUploadFileFinished_Eresult +} + +func (m *CMsgClientUFSUploadFileFinished) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +type CMsgClientUFSDeleteFileRequest struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + FileName *string `protobuf:"bytes,2,opt,name=file_name" json:"file_name,omitempty"` + IsExplicitDelete *bool `protobuf:"varint,3,opt,name=is_explicit_delete" json:"is_explicit_delete,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSDeleteFileRequest) Reset() { *m = CMsgClientUFSDeleteFileRequest{} } +func (m *CMsgClientUFSDeleteFileRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSDeleteFileRequest) ProtoMessage() {} +func (*CMsgClientUFSDeleteFileRequest) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{105} +} + +func (m *CMsgClientUFSDeleteFileRequest) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSDeleteFileRequest) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +func (m *CMsgClientUFSDeleteFileRequest) GetIsExplicitDelete() bool { + if m != nil && m.IsExplicitDelete != nil { + return *m.IsExplicitDelete + } + return false +} + +type CMsgClientUFSDeleteFileResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + FileName *string `protobuf:"bytes,2,opt,name=file_name" json:"file_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSDeleteFileResponse) Reset() { *m = CMsgClientUFSDeleteFileResponse{} } +func (m *CMsgClientUFSDeleteFileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSDeleteFileResponse) ProtoMessage() {} +func (*CMsgClientUFSDeleteFileResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{106} +} + +const Default_CMsgClientUFSDeleteFileResponse_Eresult int32 = 2 + +func (m *CMsgClientUFSDeleteFileResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSDeleteFileResponse_Eresult +} + +func (m *CMsgClientUFSDeleteFileResponse) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +type CMsgClientUFSGetFileListForApp struct { + AppsToQuery []uint32 `protobuf:"varint,1,rep,name=apps_to_query" json:"apps_to_query,omitempty"` + SendPathPrefixes *bool `protobuf:"varint,2,opt,name=send_path_prefixes" json:"send_path_prefixes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSGetFileListForApp) Reset() { *m = CMsgClientUFSGetFileListForApp{} } +func (m *CMsgClientUFSGetFileListForApp) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSGetFileListForApp) ProtoMessage() {} +func (*CMsgClientUFSGetFileListForApp) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{107} +} + +func (m *CMsgClientUFSGetFileListForApp) GetAppsToQuery() []uint32 { + if m != nil { + return m.AppsToQuery + } + return nil +} + +func (m *CMsgClientUFSGetFileListForApp) GetSendPathPrefixes() bool { + if m != nil && m.SendPathPrefixes != nil { + return *m.SendPathPrefixes + } + return false +} + +type CMsgClientUFSGetFileListForAppResponse struct { + Files []*CMsgClientUFSGetFileListForAppResponse_File `protobuf:"bytes,1,rep,name=files" json:"files,omitempty"` + PathPrefixes []string `protobuf:"bytes,2,rep,name=path_prefixes" json:"path_prefixes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSGetFileListForAppResponse) Reset() { + *m = CMsgClientUFSGetFileListForAppResponse{} +} +func (m *CMsgClientUFSGetFileListForAppResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSGetFileListForAppResponse) ProtoMessage() {} +func (*CMsgClientUFSGetFileListForAppResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{108} +} + +func (m *CMsgClientUFSGetFileListForAppResponse) GetFiles() []*CMsgClientUFSGetFileListForAppResponse_File { + if m != nil { + return m.Files + } + return nil +} + +func (m *CMsgClientUFSGetFileListForAppResponse) GetPathPrefixes() []string { + if m != nil { + return m.PathPrefixes + } + return nil +} + +type CMsgClientUFSGetFileListForAppResponse_File struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + FileName *string `protobuf:"bytes,2,opt,name=file_name" json:"file_name,omitempty"` + ShaFile []byte `protobuf:"bytes,3,opt,name=sha_file" json:"sha_file,omitempty"` + TimeStamp *uint64 `protobuf:"varint,4,opt,name=time_stamp" json:"time_stamp,omitempty"` + RawFileSize *uint32 `protobuf:"varint,5,opt,name=raw_file_size" json:"raw_file_size,omitempty"` + IsExplicitDelete *bool `protobuf:"varint,6,opt,name=is_explicit_delete" json:"is_explicit_delete,omitempty"` + PlatformsToSync *uint32 `protobuf:"varint,7,opt,name=platforms_to_sync" json:"platforms_to_sync,omitempty"` + PathPrefixIndex *uint32 `protobuf:"varint,8,opt,name=path_prefix_index" json:"path_prefix_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) Reset() { + *m = CMsgClientUFSGetFileListForAppResponse_File{} +} +func (m *CMsgClientUFSGetFileListForAppResponse_File) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUFSGetFileListForAppResponse_File) ProtoMessage() {} +func (*CMsgClientUFSGetFileListForAppResponse_File) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{108, 0} +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetTimeStamp() uint64 { + if m != nil && m.TimeStamp != nil { + return *m.TimeStamp + } + return 0 +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetRawFileSize() uint32 { + if m != nil && m.RawFileSize != nil { + return *m.RawFileSize + } + return 0 +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetIsExplicitDelete() bool { + if m != nil && m.IsExplicitDelete != nil { + return *m.IsExplicitDelete + } + return false +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetPlatformsToSync() uint32 { + if m != nil && m.PlatformsToSync != nil { + return *m.PlatformsToSync + } + return 0 +} + +func (m *CMsgClientUFSGetFileListForAppResponse_File) GetPathPrefixIndex() uint32 { + if m != nil && m.PathPrefixIndex != nil { + return *m.PathPrefixIndex + } + return 0 +} + +type CMsgClientUFSDownloadRequest struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + FileName *string `protobuf:"bytes,2,opt,name=file_name" json:"file_name,omitempty"` + CanHandleHttp *bool `protobuf:"varint,3,opt,name=can_handle_http" json:"can_handle_http,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSDownloadRequest) Reset() { *m = CMsgClientUFSDownloadRequest{} } +func (m *CMsgClientUFSDownloadRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSDownloadRequest) ProtoMessage() {} +func (*CMsgClientUFSDownloadRequest) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{109} } + +func (m *CMsgClientUFSDownloadRequest) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSDownloadRequest) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +func (m *CMsgClientUFSDownloadRequest) GetCanHandleHttp() bool { + if m != nil && m.CanHandleHttp != nil { + return *m.CanHandleHttp + } + return false +} + +type CMsgClientUFSDownloadResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + FileSize *uint32 `protobuf:"varint,3,opt,name=file_size" json:"file_size,omitempty"` + RawFileSize *uint32 `protobuf:"varint,4,opt,name=raw_file_size" json:"raw_file_size,omitempty"` + ShaFile []byte `protobuf:"bytes,5,opt,name=sha_file" json:"sha_file,omitempty"` + TimeStamp *uint64 `protobuf:"varint,6,opt,name=time_stamp" json:"time_stamp,omitempty"` + IsExplicitDelete *bool `protobuf:"varint,7,opt,name=is_explicit_delete" json:"is_explicit_delete,omitempty"` + UseHttp *bool `protobuf:"varint,8,opt,name=use_http" json:"use_http,omitempty"` + HttpHost *string `protobuf:"bytes,9,opt,name=http_host" json:"http_host,omitempty"` + HttpUrl *string `protobuf:"bytes,10,opt,name=http_url" json:"http_url,omitempty"` + KvHeaders []byte `protobuf:"bytes,11,opt,name=kv_headers" json:"kv_headers,omitempty"` + UseHttps *bool `protobuf:"varint,12,opt,name=use_https" json:"use_https,omitempty"` + Encrypted *bool `protobuf:"varint,13,opt,name=encrypted" json:"encrypted,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSDownloadResponse) Reset() { *m = CMsgClientUFSDownloadResponse{} } +func (m *CMsgClientUFSDownloadResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSDownloadResponse) ProtoMessage() {} +func (*CMsgClientUFSDownloadResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{110} } + +const Default_CMsgClientUFSDownloadResponse_Eresult int32 = 2 + +func (m *CMsgClientUFSDownloadResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSDownloadResponse_Eresult +} + +func (m *CMsgClientUFSDownloadResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSDownloadResponse) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CMsgClientUFSDownloadResponse) GetRawFileSize() uint32 { + if m != nil && m.RawFileSize != nil { + return *m.RawFileSize + } + return 0 +} + +func (m *CMsgClientUFSDownloadResponse) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUFSDownloadResponse) GetTimeStamp() uint64 { + if m != nil && m.TimeStamp != nil { + return *m.TimeStamp + } + return 0 +} + +func (m *CMsgClientUFSDownloadResponse) GetIsExplicitDelete() bool { + if m != nil && m.IsExplicitDelete != nil { + return *m.IsExplicitDelete + } + return false +} + +func (m *CMsgClientUFSDownloadResponse) GetUseHttp() bool { + if m != nil && m.UseHttp != nil { + return *m.UseHttp + } + return false +} + +func (m *CMsgClientUFSDownloadResponse) GetHttpHost() string { + if m != nil && m.HttpHost != nil { + return *m.HttpHost + } + return "" +} + +func (m *CMsgClientUFSDownloadResponse) GetHttpUrl() string { + if m != nil && m.HttpUrl != nil { + return *m.HttpUrl + } + return "" +} + +func (m *CMsgClientUFSDownloadResponse) GetKvHeaders() []byte { + if m != nil { + return m.KvHeaders + } + return nil +} + +func (m *CMsgClientUFSDownloadResponse) GetUseHttps() bool { + if m != nil && m.UseHttps != nil { + return *m.UseHttps + } + return false +} + +func (m *CMsgClientUFSDownloadResponse) GetEncrypted() bool { + if m != nil && m.Encrypted != nil { + return *m.Encrypted + } + return false +} + +type CMsgClientUFSLoginRequest struct { + ProtocolVersion *uint32 `protobuf:"varint,1,opt,name=protocol_version" json:"protocol_version,omitempty"` + AmSessionToken *uint64 `protobuf:"varint,2,opt,name=am_session_token" json:"am_session_token,omitempty"` + Apps []uint32 `protobuf:"varint,3,rep,name=apps" json:"apps,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSLoginRequest) Reset() { *m = CMsgClientUFSLoginRequest{} } +func (m *CMsgClientUFSLoginRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSLoginRequest) ProtoMessage() {} +func (*CMsgClientUFSLoginRequest) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{111} } + +func (m *CMsgClientUFSLoginRequest) GetProtocolVersion() uint32 { + if m != nil && m.ProtocolVersion != nil { + return *m.ProtocolVersion + } + return 0 +} + +func (m *CMsgClientUFSLoginRequest) GetAmSessionToken() uint64 { + if m != nil && m.AmSessionToken != nil { + return *m.AmSessionToken + } + return 0 +} + +func (m *CMsgClientUFSLoginRequest) GetApps() []uint32 { + if m != nil { + return m.Apps + } + return nil +} + +type CMsgClientUFSLoginResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSLoginResponse) Reset() { *m = CMsgClientUFSLoginResponse{} } +func (m *CMsgClientUFSLoginResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSLoginResponse) ProtoMessage() {} +func (*CMsgClientUFSLoginResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{112} } + +const Default_CMsgClientUFSLoginResponse_Eresult int32 = 2 + +func (m *CMsgClientUFSLoginResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSLoginResponse_Eresult +} + +type CMsgClientRequestEncryptedAppTicket struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + Userdata []byte `protobuf:"bytes,2,opt,name=userdata" json:"userdata,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestEncryptedAppTicket) Reset() { *m = CMsgClientRequestEncryptedAppTicket{} } +func (m *CMsgClientRequestEncryptedAppTicket) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestEncryptedAppTicket) ProtoMessage() {} +func (*CMsgClientRequestEncryptedAppTicket) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{113} +} + +func (m *CMsgClientRequestEncryptedAppTicket) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientRequestEncryptedAppTicket) GetUserdata() []byte { + if m != nil { + return m.Userdata + } + return nil +} + +type CMsgClientRequestEncryptedAppTicketResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + Eresult *int32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + EncryptedAppTicket *EncryptedAppTicket `protobuf:"bytes,3,opt,name=encrypted_app_ticket" json:"encrypted_app_ticket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestEncryptedAppTicketResponse) Reset() { + *m = CMsgClientRequestEncryptedAppTicketResponse{} +} +func (m *CMsgClientRequestEncryptedAppTicketResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientRequestEncryptedAppTicketResponse) ProtoMessage() {} +func (*CMsgClientRequestEncryptedAppTicketResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{114} +} + +const Default_CMsgClientRequestEncryptedAppTicketResponse_Eresult int32 = 2 + +func (m *CMsgClientRequestEncryptedAppTicketResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientRequestEncryptedAppTicketResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientRequestEncryptedAppTicketResponse_Eresult +} + +func (m *CMsgClientRequestEncryptedAppTicketResponse) GetEncryptedAppTicket() *EncryptedAppTicket { + if m != nil { + return m.EncryptedAppTicket + } + return nil +} + +type CMsgClientWalletInfoUpdate struct { + HasWallet *bool `protobuf:"varint,1,opt,name=has_wallet" json:"has_wallet,omitempty"` + Balance *int32 `protobuf:"varint,2,opt,name=balance" json:"balance,omitempty"` + Currency *int32 `protobuf:"varint,3,opt,name=currency" json:"currency,omitempty"` + BalanceDelayed *int32 `protobuf:"varint,4,opt,name=balance_delayed" json:"balance_delayed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWalletInfoUpdate) Reset() { *m = CMsgClientWalletInfoUpdate{} } +func (m *CMsgClientWalletInfoUpdate) String() string { return proto.CompactTextString(m) } +func (*CMsgClientWalletInfoUpdate) ProtoMessage() {} +func (*CMsgClientWalletInfoUpdate) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{115} } + +func (m *CMsgClientWalletInfoUpdate) GetHasWallet() bool { + if m != nil && m.HasWallet != nil { + return *m.HasWallet + } + return false +} + +func (m *CMsgClientWalletInfoUpdate) GetBalance() int32 { + if m != nil && m.Balance != nil { + return *m.Balance + } + return 0 +} + +func (m *CMsgClientWalletInfoUpdate) GetCurrency() int32 { + if m != nil && m.Currency != nil { + return *m.Currency + } + return 0 +} + +func (m *CMsgClientWalletInfoUpdate) GetBalanceDelayed() int32 { + if m != nil && m.BalanceDelayed != nil { + return *m.BalanceDelayed + } + return 0 +} + +type CMsgClientAppInfoUpdate struct { + LastChangenumber *uint32 `protobuf:"varint,1,opt,name=last_changenumber" json:"last_changenumber,omitempty"` + SendChangelist *bool `protobuf:"varint,2,opt,name=send_changelist" json:"send_changelist,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppInfoUpdate) Reset() { *m = CMsgClientAppInfoUpdate{} } +func (m *CMsgClientAppInfoUpdate) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppInfoUpdate) ProtoMessage() {} +func (*CMsgClientAppInfoUpdate) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{116} } + +func (m *CMsgClientAppInfoUpdate) GetLastChangenumber() uint32 { + if m != nil && m.LastChangenumber != nil { + return *m.LastChangenumber + } + return 0 +} + +func (m *CMsgClientAppInfoUpdate) GetSendChangelist() bool { + if m != nil && m.SendChangelist != nil { + return *m.SendChangelist + } + return false +} + +type CMsgClientAppInfoChanges struct { + CurrentChangeNumber *uint32 `protobuf:"varint,1,opt,name=current_change_number" json:"current_change_number,omitempty"` + ForceFullUpdate *bool `protobuf:"varint,2,opt,name=force_full_update" json:"force_full_update,omitempty"` + AppIDs []uint32 `protobuf:"varint,3,rep,name=appIDs" json:"appIDs,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppInfoChanges) Reset() { *m = CMsgClientAppInfoChanges{} } +func (m *CMsgClientAppInfoChanges) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppInfoChanges) ProtoMessage() {} +func (*CMsgClientAppInfoChanges) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{117} } + +func (m *CMsgClientAppInfoChanges) GetCurrentChangeNumber() uint32 { + if m != nil && m.CurrentChangeNumber != nil { + return *m.CurrentChangeNumber + } + return 0 +} + +func (m *CMsgClientAppInfoChanges) GetForceFullUpdate() bool { + if m != nil && m.ForceFullUpdate != nil { + return *m.ForceFullUpdate + } + return false +} + +func (m *CMsgClientAppInfoChanges) GetAppIDs() []uint32 { + if m != nil { + return m.AppIDs + } + return nil +} + +type CMsgClientAppInfoRequest struct { + Apps []*CMsgClientAppInfoRequest_App `protobuf:"bytes,1,rep,name=apps" json:"apps,omitempty"` + SupportsBatches *bool `protobuf:"varint,2,opt,name=supports_batches,def=0" json:"supports_batches,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppInfoRequest) Reset() { *m = CMsgClientAppInfoRequest{} } +func (m *CMsgClientAppInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppInfoRequest) ProtoMessage() {} +func (*CMsgClientAppInfoRequest) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{118} } + +const Default_CMsgClientAppInfoRequest_SupportsBatches bool = false + +func (m *CMsgClientAppInfoRequest) GetApps() []*CMsgClientAppInfoRequest_App { + if m != nil { + return m.Apps + } + return nil +} + +func (m *CMsgClientAppInfoRequest) GetSupportsBatches() bool { + if m != nil && m.SupportsBatches != nil { + return *m.SupportsBatches + } + return Default_CMsgClientAppInfoRequest_SupportsBatches +} + +type CMsgClientAppInfoRequest_App struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + SectionFlags *uint32 `protobuf:"varint,2,opt,name=section_flags" json:"section_flags,omitempty"` + Section_CRC []uint32 `protobuf:"varint,3,rep,name=section_CRC" json:"section_CRC,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppInfoRequest_App) Reset() { *m = CMsgClientAppInfoRequest_App{} } +func (m *CMsgClientAppInfoRequest_App) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppInfoRequest_App) ProtoMessage() {} +func (*CMsgClientAppInfoRequest_App) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{118, 0} +} + +func (m *CMsgClientAppInfoRequest_App) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientAppInfoRequest_App) GetSectionFlags() uint32 { + if m != nil && m.SectionFlags != nil { + return *m.SectionFlags + } + return 0 +} + +func (m *CMsgClientAppInfoRequest_App) GetSection_CRC() []uint32 { + if m != nil { + return m.Section_CRC + } + return nil +} + +type CMsgClientAppInfoResponse struct { + Apps []*CMsgClientAppInfoResponse_App `protobuf:"bytes,1,rep,name=apps" json:"apps,omitempty"` + AppsUnknown []uint32 `protobuf:"varint,2,rep,name=apps_unknown" json:"apps_unknown,omitempty"` + AppsPending *uint32 `protobuf:"varint,3,opt,name=apps_pending" json:"apps_pending,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppInfoResponse) Reset() { *m = CMsgClientAppInfoResponse{} } +func (m *CMsgClientAppInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppInfoResponse) ProtoMessage() {} +func (*CMsgClientAppInfoResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{119} } + +func (m *CMsgClientAppInfoResponse) GetApps() []*CMsgClientAppInfoResponse_App { + if m != nil { + return m.Apps + } + return nil +} + +func (m *CMsgClientAppInfoResponse) GetAppsUnknown() []uint32 { + if m != nil { + return m.AppsUnknown + } + return nil +} + +func (m *CMsgClientAppInfoResponse) GetAppsPending() uint32 { + if m != nil && m.AppsPending != nil { + return *m.AppsPending + } + return 0 +} + +type CMsgClientAppInfoResponse_App struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + ChangeNumber *uint32 `protobuf:"varint,2,opt,name=change_number" json:"change_number,omitempty"` + Sections []*CMsgClientAppInfoResponse_App_Section `protobuf:"bytes,3,rep,name=sections" json:"sections,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppInfoResponse_App) Reset() { *m = CMsgClientAppInfoResponse_App{} } +func (m *CMsgClientAppInfoResponse_App) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppInfoResponse_App) ProtoMessage() {} +func (*CMsgClientAppInfoResponse_App) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{119, 0} +} + +func (m *CMsgClientAppInfoResponse_App) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientAppInfoResponse_App) GetChangeNumber() uint32 { + if m != nil && m.ChangeNumber != nil { + return *m.ChangeNumber + } + return 0 +} + +func (m *CMsgClientAppInfoResponse_App) GetSections() []*CMsgClientAppInfoResponse_App_Section { + if m != nil { + return m.Sections + } + return nil +} + +type CMsgClientAppInfoResponse_App_Section struct { + SectionId *uint32 `protobuf:"varint,1,opt,name=section_id" json:"section_id,omitempty"` + SectionKv []byte `protobuf:"bytes,2,opt,name=section_kv" json:"section_kv,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAppInfoResponse_App_Section) Reset() { *m = CMsgClientAppInfoResponse_App_Section{} } +func (m *CMsgClientAppInfoResponse_App_Section) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAppInfoResponse_App_Section) ProtoMessage() {} +func (*CMsgClientAppInfoResponse_App_Section) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{119, 0, 0} +} + +func (m *CMsgClientAppInfoResponse_App_Section) GetSectionId() uint32 { + if m != nil && m.SectionId != nil { + return *m.SectionId + } + return 0 +} + +func (m *CMsgClientAppInfoResponse_App_Section) GetSectionKv() []byte { + if m != nil { + return m.SectionKv + } + return nil +} + +type CMsgClientPackageInfoRequest struct { + PackageIds []uint32 `protobuf:"varint,1,rep,name=package_ids" json:"package_ids,omitempty"` + MetaDataOnly *bool `protobuf:"varint,2,opt,name=meta_data_only" json:"meta_data_only,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPackageInfoRequest) Reset() { *m = CMsgClientPackageInfoRequest{} } +func (m *CMsgClientPackageInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPackageInfoRequest) ProtoMessage() {} +func (*CMsgClientPackageInfoRequest) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{120} } + +func (m *CMsgClientPackageInfoRequest) GetPackageIds() []uint32 { + if m != nil { + return m.PackageIds + } + return nil +} + +func (m *CMsgClientPackageInfoRequest) GetMetaDataOnly() bool { + if m != nil && m.MetaDataOnly != nil { + return *m.MetaDataOnly + } + return false +} + +type CMsgClientPackageInfoResponse struct { + Packages []*CMsgClientPackageInfoResponse_Package `protobuf:"bytes,1,rep,name=packages" json:"packages,omitempty"` + PackagesUnknown []uint32 `protobuf:"varint,2,rep,name=packages_unknown" json:"packages_unknown,omitempty"` + PackagesPending *uint32 `protobuf:"varint,3,opt,name=packages_pending" json:"packages_pending,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPackageInfoResponse) Reset() { *m = CMsgClientPackageInfoResponse{} } +func (m *CMsgClientPackageInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPackageInfoResponse) ProtoMessage() {} +func (*CMsgClientPackageInfoResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{121} } + +func (m *CMsgClientPackageInfoResponse) GetPackages() []*CMsgClientPackageInfoResponse_Package { + if m != nil { + return m.Packages + } + return nil +} + +func (m *CMsgClientPackageInfoResponse) GetPackagesUnknown() []uint32 { + if m != nil { + return m.PackagesUnknown + } + return nil +} + +func (m *CMsgClientPackageInfoResponse) GetPackagesPending() uint32 { + if m != nil && m.PackagesPending != nil { + return *m.PackagesPending + } + return 0 +} + +type CMsgClientPackageInfoResponse_Package struct { + PackageId *uint32 `protobuf:"varint,1,opt,name=package_id" json:"package_id,omitempty"` + ChangeNumber *uint32 `protobuf:"varint,2,opt,name=change_number" json:"change_number,omitempty"` + Sha []byte `protobuf:"bytes,3,opt,name=sha" json:"sha,omitempty"` + Buffer []byte `protobuf:"bytes,4,opt,name=buffer" json:"buffer,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPackageInfoResponse_Package) Reset() { *m = CMsgClientPackageInfoResponse_Package{} } +func (m *CMsgClientPackageInfoResponse_Package) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPackageInfoResponse_Package) ProtoMessage() {} +func (*CMsgClientPackageInfoResponse_Package) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{121, 0} +} + +func (m *CMsgClientPackageInfoResponse_Package) GetPackageId() uint32 { + if m != nil && m.PackageId != nil { + return *m.PackageId + } + return 0 +} + +func (m *CMsgClientPackageInfoResponse_Package) GetChangeNumber() uint32 { + if m != nil && m.ChangeNumber != nil { + return *m.ChangeNumber + } + return 0 +} + +func (m *CMsgClientPackageInfoResponse_Package) GetSha() []byte { + if m != nil { + return m.Sha + } + return nil +} + +func (m *CMsgClientPackageInfoResponse_Package) GetBuffer() []byte { + if m != nil { + return m.Buffer + } + return nil +} + +type CMsgClientPICSChangesSinceRequest struct { + SinceChangeNumber *uint32 `protobuf:"varint,1,opt,name=since_change_number" json:"since_change_number,omitempty"` + SendAppInfoChanges *bool `protobuf:"varint,2,opt,name=send_app_info_changes" json:"send_app_info_changes,omitempty"` + SendPackageInfoChanges *bool `protobuf:"varint,3,opt,name=send_package_info_changes" json:"send_package_info_changes,omitempty"` + NumAppInfoCached *uint32 `protobuf:"varint,4,opt,name=num_app_info_cached" json:"num_app_info_cached,omitempty"` + NumPackageInfoCached *uint32 `protobuf:"varint,5,opt,name=num_package_info_cached" json:"num_package_info_cached,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSChangesSinceRequest) Reset() { *m = CMsgClientPICSChangesSinceRequest{} } +func (m *CMsgClientPICSChangesSinceRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSChangesSinceRequest) ProtoMessage() {} +func (*CMsgClientPICSChangesSinceRequest) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{122} +} + +func (m *CMsgClientPICSChangesSinceRequest) GetSinceChangeNumber() uint32 { + if m != nil && m.SinceChangeNumber != nil { + return *m.SinceChangeNumber + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceRequest) GetSendAppInfoChanges() bool { + if m != nil && m.SendAppInfoChanges != nil { + return *m.SendAppInfoChanges + } + return false +} + +func (m *CMsgClientPICSChangesSinceRequest) GetSendPackageInfoChanges() bool { + if m != nil && m.SendPackageInfoChanges != nil { + return *m.SendPackageInfoChanges + } + return false +} + +func (m *CMsgClientPICSChangesSinceRequest) GetNumAppInfoCached() uint32 { + if m != nil && m.NumAppInfoCached != nil { + return *m.NumAppInfoCached + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceRequest) GetNumPackageInfoCached() uint32 { + if m != nil && m.NumPackageInfoCached != nil { + return *m.NumPackageInfoCached + } + return 0 +} + +type CMsgClientPICSChangesSinceResponse struct { + CurrentChangeNumber *uint32 `protobuf:"varint,1,opt,name=current_change_number" json:"current_change_number,omitempty"` + SinceChangeNumber *uint32 `protobuf:"varint,2,opt,name=since_change_number" json:"since_change_number,omitempty"` + ForceFullUpdate *bool `protobuf:"varint,3,opt,name=force_full_update" json:"force_full_update,omitempty"` + PackageChanges []*CMsgClientPICSChangesSinceResponse_PackageChange `protobuf:"bytes,4,rep,name=package_changes" json:"package_changes,omitempty"` + AppChanges []*CMsgClientPICSChangesSinceResponse_AppChange `protobuf:"bytes,5,rep,name=app_changes" json:"app_changes,omitempty"` + ForceFullAppUpdate *bool `protobuf:"varint,6,opt,name=force_full_app_update" json:"force_full_app_update,omitempty"` + ForceFullPackageUpdate *bool `protobuf:"varint,7,opt,name=force_full_package_update" json:"force_full_package_update,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSChangesSinceResponse) Reset() { *m = CMsgClientPICSChangesSinceResponse{} } +func (m *CMsgClientPICSChangesSinceResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSChangesSinceResponse) ProtoMessage() {} +func (*CMsgClientPICSChangesSinceResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{123} +} + +func (m *CMsgClientPICSChangesSinceResponse) GetCurrentChangeNumber() uint32 { + if m != nil && m.CurrentChangeNumber != nil { + return *m.CurrentChangeNumber + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceResponse) GetSinceChangeNumber() uint32 { + if m != nil && m.SinceChangeNumber != nil { + return *m.SinceChangeNumber + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceResponse) GetForceFullUpdate() bool { + if m != nil && m.ForceFullUpdate != nil { + return *m.ForceFullUpdate + } + return false +} + +func (m *CMsgClientPICSChangesSinceResponse) GetPackageChanges() []*CMsgClientPICSChangesSinceResponse_PackageChange { + if m != nil { + return m.PackageChanges + } + return nil +} + +func (m *CMsgClientPICSChangesSinceResponse) GetAppChanges() []*CMsgClientPICSChangesSinceResponse_AppChange { + if m != nil { + return m.AppChanges + } + return nil +} + +func (m *CMsgClientPICSChangesSinceResponse) GetForceFullAppUpdate() bool { + if m != nil && m.ForceFullAppUpdate != nil { + return *m.ForceFullAppUpdate + } + return false +} + +func (m *CMsgClientPICSChangesSinceResponse) GetForceFullPackageUpdate() bool { + if m != nil && m.ForceFullPackageUpdate != nil { + return *m.ForceFullPackageUpdate + } + return false +} + +type CMsgClientPICSChangesSinceResponse_PackageChange struct { + Packageid *uint32 `protobuf:"varint,1,opt,name=packageid" json:"packageid,omitempty"` + ChangeNumber *uint32 `protobuf:"varint,2,opt,name=change_number" json:"change_number,omitempty"` + NeedsToken *bool `protobuf:"varint,3,opt,name=needs_token" json:"needs_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSChangesSinceResponse_PackageChange) Reset() { + *m = CMsgClientPICSChangesSinceResponse_PackageChange{} +} +func (m *CMsgClientPICSChangesSinceResponse_PackageChange) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientPICSChangesSinceResponse_PackageChange) ProtoMessage() {} +func (*CMsgClientPICSChangesSinceResponse_PackageChange) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{123, 0} +} + +func (m *CMsgClientPICSChangesSinceResponse_PackageChange) GetPackageid() uint32 { + if m != nil && m.Packageid != nil { + return *m.Packageid + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceResponse_PackageChange) GetChangeNumber() uint32 { + if m != nil && m.ChangeNumber != nil { + return *m.ChangeNumber + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceResponse_PackageChange) GetNeedsToken() bool { + if m != nil && m.NeedsToken != nil { + return *m.NeedsToken + } + return false +} + +type CMsgClientPICSChangesSinceResponse_AppChange struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + ChangeNumber *uint32 `protobuf:"varint,2,opt,name=change_number" json:"change_number,omitempty"` + NeedsToken *bool `protobuf:"varint,3,opt,name=needs_token" json:"needs_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSChangesSinceResponse_AppChange) Reset() { + *m = CMsgClientPICSChangesSinceResponse_AppChange{} +} +func (m *CMsgClientPICSChangesSinceResponse_AppChange) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientPICSChangesSinceResponse_AppChange) ProtoMessage() {} +func (*CMsgClientPICSChangesSinceResponse_AppChange) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{123, 1} +} + +func (m *CMsgClientPICSChangesSinceResponse_AppChange) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceResponse_AppChange) GetChangeNumber() uint32 { + if m != nil && m.ChangeNumber != nil { + return *m.ChangeNumber + } + return 0 +} + +func (m *CMsgClientPICSChangesSinceResponse_AppChange) GetNeedsToken() bool { + if m != nil && m.NeedsToken != nil { + return *m.NeedsToken + } + return false +} + +type CMsgClientPICSProductInfoRequest struct { + Packages []*CMsgClientPICSProductInfoRequest_PackageInfo `protobuf:"bytes,1,rep,name=packages" json:"packages,omitempty"` + Apps []*CMsgClientPICSProductInfoRequest_AppInfo `protobuf:"bytes,2,rep,name=apps" json:"apps,omitempty"` + MetaDataOnly *bool `protobuf:"varint,3,opt,name=meta_data_only" json:"meta_data_only,omitempty"` + NumPrevFailed *uint32 `protobuf:"varint,4,opt,name=num_prev_failed" json:"num_prev_failed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSProductInfoRequest) Reset() { *m = CMsgClientPICSProductInfoRequest{} } +func (m *CMsgClientPICSProductInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSProductInfoRequest) ProtoMessage() {} +func (*CMsgClientPICSProductInfoRequest) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{124} +} + +func (m *CMsgClientPICSProductInfoRequest) GetPackages() []*CMsgClientPICSProductInfoRequest_PackageInfo { + if m != nil { + return m.Packages + } + return nil +} + +func (m *CMsgClientPICSProductInfoRequest) GetApps() []*CMsgClientPICSProductInfoRequest_AppInfo { + if m != nil { + return m.Apps + } + return nil +} + +func (m *CMsgClientPICSProductInfoRequest) GetMetaDataOnly() bool { + if m != nil && m.MetaDataOnly != nil { + return *m.MetaDataOnly + } + return false +} + +func (m *CMsgClientPICSProductInfoRequest) GetNumPrevFailed() uint32 { + if m != nil && m.NumPrevFailed != nil { + return *m.NumPrevFailed + } + return 0 +} + +type CMsgClientPICSProductInfoRequest_AppInfo struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + AccessToken *uint64 `protobuf:"varint,2,opt,name=access_token" json:"access_token,omitempty"` + OnlyPublic *bool `protobuf:"varint,3,opt,name=only_public" json:"only_public,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSProductInfoRequest_AppInfo) Reset() { + *m = CMsgClientPICSProductInfoRequest_AppInfo{} +} +func (m *CMsgClientPICSProductInfoRequest_AppInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSProductInfoRequest_AppInfo) ProtoMessage() {} +func (*CMsgClientPICSProductInfoRequest_AppInfo) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{124, 0} +} + +func (m *CMsgClientPICSProductInfoRequest_AppInfo) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientPICSProductInfoRequest_AppInfo) GetAccessToken() uint64 { + if m != nil && m.AccessToken != nil { + return *m.AccessToken + } + return 0 +} + +func (m *CMsgClientPICSProductInfoRequest_AppInfo) GetOnlyPublic() bool { + if m != nil && m.OnlyPublic != nil { + return *m.OnlyPublic + } + return false +} + +type CMsgClientPICSProductInfoRequest_PackageInfo struct { + Packageid *uint32 `protobuf:"varint,1,opt,name=packageid" json:"packageid,omitempty"` + AccessToken *uint64 `protobuf:"varint,2,opt,name=access_token" json:"access_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSProductInfoRequest_PackageInfo) Reset() { + *m = CMsgClientPICSProductInfoRequest_PackageInfo{} +} +func (m *CMsgClientPICSProductInfoRequest_PackageInfo) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientPICSProductInfoRequest_PackageInfo) ProtoMessage() {} +func (*CMsgClientPICSProductInfoRequest_PackageInfo) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{124, 1} +} + +func (m *CMsgClientPICSProductInfoRequest_PackageInfo) GetPackageid() uint32 { + if m != nil && m.Packageid != nil { + return *m.Packageid + } + return 0 +} + +func (m *CMsgClientPICSProductInfoRequest_PackageInfo) GetAccessToken() uint64 { + if m != nil && m.AccessToken != nil { + return *m.AccessToken + } + return 0 +} + +type CMsgClientPICSProductInfoResponse struct { + Apps []*CMsgClientPICSProductInfoResponse_AppInfo `protobuf:"bytes,1,rep,name=apps" json:"apps,omitempty"` + UnknownAppids []uint32 `protobuf:"varint,2,rep,name=unknown_appids" json:"unknown_appids,omitempty"` + Packages []*CMsgClientPICSProductInfoResponse_PackageInfo `protobuf:"bytes,3,rep,name=packages" json:"packages,omitempty"` + UnknownPackageids []uint32 `protobuf:"varint,4,rep,name=unknown_packageids" json:"unknown_packageids,omitempty"` + MetaDataOnly *bool `protobuf:"varint,5,opt,name=meta_data_only" json:"meta_data_only,omitempty"` + ResponsePending *bool `protobuf:"varint,6,opt,name=response_pending" json:"response_pending,omitempty"` + HttpMinSize *uint32 `protobuf:"varint,7,opt,name=http_min_size" json:"http_min_size,omitempty"` + HttpHost *string `protobuf:"bytes,8,opt,name=http_host" json:"http_host,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSProductInfoResponse) Reset() { *m = CMsgClientPICSProductInfoResponse{} } +func (m *CMsgClientPICSProductInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSProductInfoResponse) ProtoMessage() {} +func (*CMsgClientPICSProductInfoResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{125} +} + +func (m *CMsgClientPICSProductInfoResponse) GetApps() []*CMsgClientPICSProductInfoResponse_AppInfo { + if m != nil { + return m.Apps + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse) GetUnknownAppids() []uint32 { + if m != nil { + return m.UnknownAppids + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse) GetPackages() []*CMsgClientPICSProductInfoResponse_PackageInfo { + if m != nil { + return m.Packages + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse) GetUnknownPackageids() []uint32 { + if m != nil { + return m.UnknownPackageids + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse) GetMetaDataOnly() bool { + if m != nil && m.MetaDataOnly != nil { + return *m.MetaDataOnly + } + return false +} + +func (m *CMsgClientPICSProductInfoResponse) GetResponsePending() bool { + if m != nil && m.ResponsePending != nil { + return *m.ResponsePending + } + return false +} + +func (m *CMsgClientPICSProductInfoResponse) GetHttpMinSize() uint32 { + if m != nil && m.HttpMinSize != nil { + return *m.HttpMinSize + } + return 0 +} + +func (m *CMsgClientPICSProductInfoResponse) GetHttpHost() string { + if m != nil && m.HttpHost != nil { + return *m.HttpHost + } + return "" +} + +type CMsgClientPICSProductInfoResponse_AppInfo struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + ChangeNumber *uint32 `protobuf:"varint,2,opt,name=change_number" json:"change_number,omitempty"` + MissingToken *bool `protobuf:"varint,3,opt,name=missing_token" json:"missing_token,omitempty"` + Sha []byte `protobuf:"bytes,4,opt,name=sha" json:"sha,omitempty"` + Buffer []byte `protobuf:"bytes,5,opt,name=buffer" json:"buffer,omitempty"` + OnlyPublic *bool `protobuf:"varint,6,opt,name=only_public" json:"only_public,omitempty"` + Size *uint32 `protobuf:"varint,7,opt,name=size" json:"size,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) Reset() { + *m = CMsgClientPICSProductInfoResponse_AppInfo{} +} +func (m *CMsgClientPICSProductInfoResponse_AppInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSProductInfoResponse_AppInfo) ProtoMessage() {} +func (*CMsgClientPICSProductInfoResponse_AppInfo) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{125, 0} +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) GetChangeNumber() uint32 { + if m != nil && m.ChangeNumber != nil { + return *m.ChangeNumber + } + return 0 +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) GetMissingToken() bool { + if m != nil && m.MissingToken != nil { + return *m.MissingToken + } + return false +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) GetSha() []byte { + if m != nil { + return m.Sha + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) GetBuffer() []byte { + if m != nil { + return m.Buffer + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) GetOnlyPublic() bool { + if m != nil && m.OnlyPublic != nil { + return *m.OnlyPublic + } + return false +} + +func (m *CMsgClientPICSProductInfoResponse_AppInfo) GetSize() uint32 { + if m != nil && m.Size != nil { + return *m.Size + } + return 0 +} + +type CMsgClientPICSProductInfoResponse_PackageInfo struct { + Packageid *uint32 `protobuf:"varint,1,opt,name=packageid" json:"packageid,omitempty"` + ChangeNumber *uint32 `protobuf:"varint,2,opt,name=change_number" json:"change_number,omitempty"` + MissingToken *bool `protobuf:"varint,3,opt,name=missing_token" json:"missing_token,omitempty"` + Sha []byte `protobuf:"bytes,4,opt,name=sha" json:"sha,omitempty"` + Buffer []byte `protobuf:"bytes,5,opt,name=buffer" json:"buffer,omitempty"` + Size *uint32 `protobuf:"varint,6,opt,name=size" json:"size,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) Reset() { + *m = CMsgClientPICSProductInfoResponse_PackageInfo{} +} +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientPICSProductInfoResponse_PackageInfo) ProtoMessage() {} +func (*CMsgClientPICSProductInfoResponse_PackageInfo) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{125, 1} +} + +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) GetPackageid() uint32 { + if m != nil && m.Packageid != nil { + return *m.Packageid + } + return 0 +} + +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) GetChangeNumber() uint32 { + if m != nil && m.ChangeNumber != nil { + return *m.ChangeNumber + } + return 0 +} + +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) GetMissingToken() bool { + if m != nil && m.MissingToken != nil { + return *m.MissingToken + } + return false +} + +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) GetSha() []byte { + if m != nil { + return m.Sha + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) GetBuffer() []byte { + if m != nil { + return m.Buffer + } + return nil +} + +func (m *CMsgClientPICSProductInfoResponse_PackageInfo) GetSize() uint32 { + if m != nil && m.Size != nil { + return *m.Size + } + return 0 +} + +type CMsgClientPICSAccessTokenRequest struct { + Packageids []uint32 `protobuf:"varint,1,rep,name=packageids" json:"packageids,omitempty"` + Appids []uint32 `protobuf:"varint,2,rep,name=appids" json:"appids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSAccessTokenRequest) Reset() { *m = CMsgClientPICSAccessTokenRequest{} } +func (m *CMsgClientPICSAccessTokenRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSAccessTokenRequest) ProtoMessage() {} +func (*CMsgClientPICSAccessTokenRequest) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{126} +} + +func (m *CMsgClientPICSAccessTokenRequest) GetPackageids() []uint32 { + if m != nil { + return m.Packageids + } + return nil +} + +func (m *CMsgClientPICSAccessTokenRequest) GetAppids() []uint32 { + if m != nil { + return m.Appids + } + return nil +} + +type CMsgClientPICSAccessTokenResponse struct { + PackageAccessTokens []*CMsgClientPICSAccessTokenResponse_PackageToken `protobuf:"bytes,1,rep,name=package_access_tokens" json:"package_access_tokens,omitempty"` + PackageDeniedTokens []uint32 `protobuf:"varint,2,rep,name=package_denied_tokens" json:"package_denied_tokens,omitempty"` + AppAccessTokens []*CMsgClientPICSAccessTokenResponse_AppToken `protobuf:"bytes,3,rep,name=app_access_tokens" json:"app_access_tokens,omitempty"` + AppDeniedTokens []uint32 `protobuf:"varint,4,rep,name=app_denied_tokens" json:"app_denied_tokens,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSAccessTokenResponse) Reset() { *m = CMsgClientPICSAccessTokenResponse{} } +func (m *CMsgClientPICSAccessTokenResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPICSAccessTokenResponse) ProtoMessage() {} +func (*CMsgClientPICSAccessTokenResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{127} +} + +func (m *CMsgClientPICSAccessTokenResponse) GetPackageAccessTokens() []*CMsgClientPICSAccessTokenResponse_PackageToken { + if m != nil { + return m.PackageAccessTokens + } + return nil +} + +func (m *CMsgClientPICSAccessTokenResponse) GetPackageDeniedTokens() []uint32 { + if m != nil { + return m.PackageDeniedTokens + } + return nil +} + +func (m *CMsgClientPICSAccessTokenResponse) GetAppAccessTokens() []*CMsgClientPICSAccessTokenResponse_AppToken { + if m != nil { + return m.AppAccessTokens + } + return nil +} + +func (m *CMsgClientPICSAccessTokenResponse) GetAppDeniedTokens() []uint32 { + if m != nil { + return m.AppDeniedTokens + } + return nil +} + +type CMsgClientPICSAccessTokenResponse_PackageToken struct { + Packageid *uint32 `protobuf:"varint,1,opt,name=packageid" json:"packageid,omitempty"` + AccessToken *uint64 `protobuf:"varint,2,opt,name=access_token" json:"access_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSAccessTokenResponse_PackageToken) Reset() { + *m = CMsgClientPICSAccessTokenResponse_PackageToken{} +} +func (m *CMsgClientPICSAccessTokenResponse_PackageToken) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientPICSAccessTokenResponse_PackageToken) ProtoMessage() {} +func (*CMsgClientPICSAccessTokenResponse_PackageToken) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{127, 0} +} + +func (m *CMsgClientPICSAccessTokenResponse_PackageToken) GetPackageid() uint32 { + if m != nil && m.Packageid != nil { + return *m.Packageid + } + return 0 +} + +func (m *CMsgClientPICSAccessTokenResponse_PackageToken) GetAccessToken() uint64 { + if m != nil && m.AccessToken != nil { + return *m.AccessToken + } + return 0 +} + +type CMsgClientPICSAccessTokenResponse_AppToken struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + AccessToken *uint64 `protobuf:"varint,2,opt,name=access_token" json:"access_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPICSAccessTokenResponse_AppToken) Reset() { + *m = CMsgClientPICSAccessTokenResponse_AppToken{} +} +func (m *CMsgClientPICSAccessTokenResponse_AppToken) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientPICSAccessTokenResponse_AppToken) ProtoMessage() {} +func (*CMsgClientPICSAccessTokenResponse_AppToken) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{127, 1} +} + +func (m *CMsgClientPICSAccessTokenResponse_AppToken) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientPICSAccessTokenResponse_AppToken) GetAccessToken() uint64 { + if m != nil && m.AccessToken != nil { + return *m.AccessToken + } + return 0 +} + +type CMsgClientUFSGetUGCDetails struct { + Hcontent *uint64 `protobuf:"fixed64,1,opt,name=hcontent,def=18446744073709551615" json:"hcontent,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSGetUGCDetails) Reset() { *m = CMsgClientUFSGetUGCDetails{} } +func (m *CMsgClientUFSGetUGCDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSGetUGCDetails) ProtoMessage() {} +func (*CMsgClientUFSGetUGCDetails) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{128} } + +const Default_CMsgClientUFSGetUGCDetails_Hcontent uint64 = 18446744073709551615 + +func (m *CMsgClientUFSGetUGCDetails) GetHcontent() uint64 { + if m != nil && m.Hcontent != nil { + return *m.Hcontent + } + return Default_CMsgClientUFSGetUGCDetails_Hcontent +} + +type CMsgClientUFSGetUGCDetailsResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Url *string `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"` + AppId *uint32 `protobuf:"varint,3,opt,name=app_id" json:"app_id,omitempty"` + Filename *string `protobuf:"bytes,4,opt,name=filename" json:"filename,omitempty"` + SteamidCreator *uint64 `protobuf:"fixed64,5,opt,name=steamid_creator" json:"steamid_creator,omitempty"` + FileSize *uint32 `protobuf:"varint,6,opt,name=file_size" json:"file_size,omitempty"` + CompressedFileSize *uint32 `protobuf:"varint,7,opt,name=compressed_file_size" json:"compressed_file_size,omitempty"` + RangecheckHost *string `protobuf:"bytes,8,opt,name=rangecheck_host" json:"rangecheck_host,omitempty"` + FileEncodedSha1 *string `protobuf:"bytes,9,opt,name=file_encoded_sha1" json:"file_encoded_sha1,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) Reset() { *m = CMsgClientUFSGetUGCDetailsResponse{} } +func (m *CMsgClientUFSGetUGCDetailsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSGetUGCDetailsResponse) ProtoMessage() {} +func (*CMsgClientUFSGetUGCDetailsResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{129} +} + +const Default_CMsgClientUFSGetUGCDetailsResponse_Eresult int32 = 2 + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSGetUGCDetailsResponse_Eresult +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetSteamidCreator() uint64 { + if m != nil && m.SteamidCreator != nil { + return *m.SteamidCreator + } + return 0 +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetCompressedFileSize() uint32 { + if m != nil && m.CompressedFileSize != nil { + return *m.CompressedFileSize + } + return 0 +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetRangecheckHost() string { + if m != nil && m.RangecheckHost != nil { + return *m.RangecheckHost + } + return "" +} + +func (m *CMsgClientUFSGetUGCDetailsResponse) GetFileEncodedSha1() string { + if m != nil && m.FileEncodedSha1 != nil { + return *m.FileEncodedSha1 + } + return "" +} + +type CMsgClientUFSGetSingleFileInfo struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + FileName *string `protobuf:"bytes,2,opt,name=file_name" json:"file_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSGetSingleFileInfo) Reset() { *m = CMsgClientUFSGetSingleFileInfo{} } +func (m *CMsgClientUFSGetSingleFileInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSGetSingleFileInfo) ProtoMessage() {} +func (*CMsgClientUFSGetSingleFileInfo) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{130} +} + +func (m *CMsgClientUFSGetSingleFileInfo) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSGetSingleFileInfo) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +type CMsgClientUFSGetSingleFileInfoResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + FileName *string `protobuf:"bytes,3,opt,name=file_name" json:"file_name,omitempty"` + ShaFile []byte `protobuf:"bytes,4,opt,name=sha_file" json:"sha_file,omitempty"` + TimeStamp *uint64 `protobuf:"varint,5,opt,name=time_stamp" json:"time_stamp,omitempty"` + RawFileSize *uint32 `protobuf:"varint,6,opt,name=raw_file_size" json:"raw_file_size,omitempty"` + IsExplicitDelete *bool `protobuf:"varint,7,opt,name=is_explicit_delete" json:"is_explicit_delete,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSGetSingleFileInfoResponse) Reset() { + *m = CMsgClientUFSGetSingleFileInfoResponse{} +} +func (m *CMsgClientUFSGetSingleFileInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSGetSingleFileInfoResponse) ProtoMessage() {} +func (*CMsgClientUFSGetSingleFileInfoResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{131} +} + +const Default_CMsgClientUFSGetSingleFileInfoResponse_Eresult int32 = 2 + +func (m *CMsgClientUFSGetSingleFileInfoResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSGetSingleFileInfoResponse_Eresult +} + +func (m *CMsgClientUFSGetSingleFileInfoResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSGetSingleFileInfoResponse) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +func (m *CMsgClientUFSGetSingleFileInfoResponse) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUFSGetSingleFileInfoResponse) GetTimeStamp() uint64 { + if m != nil && m.TimeStamp != nil { + return *m.TimeStamp + } + return 0 +} + +func (m *CMsgClientUFSGetSingleFileInfoResponse) GetRawFileSize() uint32 { + if m != nil && m.RawFileSize != nil { + return *m.RawFileSize + } + return 0 +} + +func (m *CMsgClientUFSGetSingleFileInfoResponse) GetIsExplicitDelete() bool { + if m != nil && m.IsExplicitDelete != nil { + return *m.IsExplicitDelete + } + return false +} + +type CMsgClientUFSShareFile struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + FileName *string `protobuf:"bytes,2,opt,name=file_name" json:"file_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSShareFile) Reset() { *m = CMsgClientUFSShareFile{} } +func (m *CMsgClientUFSShareFile) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSShareFile) ProtoMessage() {} +func (*CMsgClientUFSShareFile) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{132} } + +func (m *CMsgClientUFSShareFile) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUFSShareFile) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +type CMsgClientUFSShareFileResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Hcontent *uint64 `protobuf:"fixed64,2,opt,name=hcontent,def=18446744073709551615" json:"hcontent,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUFSShareFileResponse) Reset() { *m = CMsgClientUFSShareFileResponse{} } +func (m *CMsgClientUFSShareFileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUFSShareFileResponse) ProtoMessage() {} +func (*CMsgClientUFSShareFileResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{133} +} + +const Default_CMsgClientUFSShareFileResponse_Eresult int32 = 2 +const Default_CMsgClientUFSShareFileResponse_Hcontent uint64 = 18446744073709551615 + +func (m *CMsgClientUFSShareFileResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUFSShareFileResponse_Eresult +} + +func (m *CMsgClientUFSShareFileResponse) GetHcontent() uint64 { + if m != nil && m.Hcontent != nil { + return *m.Hcontent + } + return Default_CMsgClientUFSShareFileResponse_Hcontent +} + +type CMsgClientNewLoginKey struct { + UniqueId *uint32 `protobuf:"varint,1,opt,name=unique_id" json:"unique_id,omitempty"` + LoginKey *string `protobuf:"bytes,2,opt,name=login_key" json:"login_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientNewLoginKey) Reset() { *m = CMsgClientNewLoginKey{} } +func (m *CMsgClientNewLoginKey) String() string { return proto.CompactTextString(m) } +func (*CMsgClientNewLoginKey) ProtoMessage() {} +func (*CMsgClientNewLoginKey) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{134} } + +func (m *CMsgClientNewLoginKey) GetUniqueId() uint32 { + if m != nil && m.UniqueId != nil { + return *m.UniqueId + } + return 0 +} + +func (m *CMsgClientNewLoginKey) GetLoginKey() string { + if m != nil && m.LoginKey != nil { + return *m.LoginKey + } + return "" +} + +type CMsgClientNewLoginKeyAccepted struct { + UniqueId *uint32 `protobuf:"varint,1,opt,name=unique_id" json:"unique_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientNewLoginKeyAccepted) Reset() { *m = CMsgClientNewLoginKeyAccepted{} } +func (m *CMsgClientNewLoginKeyAccepted) String() string { return proto.CompactTextString(m) } +func (*CMsgClientNewLoginKeyAccepted) ProtoMessage() {} +func (*CMsgClientNewLoginKeyAccepted) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{135} } + +func (m *CMsgClientNewLoginKeyAccepted) GetUniqueId() uint32 { + if m != nil && m.UniqueId != nil { + return *m.UniqueId + } + return 0 +} + +type CMsgClientAMGetClanOfficers struct { + SteamidClan *uint64 `protobuf:"fixed64,1,opt,name=steamid_clan" json:"steamid_clan,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAMGetClanOfficers) Reset() { *m = CMsgClientAMGetClanOfficers{} } +func (m *CMsgClientAMGetClanOfficers) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAMGetClanOfficers) ProtoMessage() {} +func (*CMsgClientAMGetClanOfficers) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{136} } + +func (m *CMsgClientAMGetClanOfficers) GetSteamidClan() uint64 { + if m != nil && m.SteamidClan != nil { + return *m.SteamidClan + } + return 0 +} + +type CMsgClientAMGetClanOfficersResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + SteamidClan *uint64 `protobuf:"fixed64,2,opt,name=steamid_clan" json:"steamid_clan,omitempty"` + OfficerCount *int32 `protobuf:"varint,3,opt,name=officer_count" json:"officer_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAMGetClanOfficersResponse) Reset() { *m = CMsgClientAMGetClanOfficersResponse{} } +func (m *CMsgClientAMGetClanOfficersResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAMGetClanOfficersResponse) ProtoMessage() {} +func (*CMsgClientAMGetClanOfficersResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{137} +} + +const Default_CMsgClientAMGetClanOfficersResponse_Eresult int32 = 2 + +func (m *CMsgClientAMGetClanOfficersResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientAMGetClanOfficersResponse_Eresult +} + +func (m *CMsgClientAMGetClanOfficersResponse) GetSteamidClan() uint64 { + if m != nil && m.SteamidClan != nil { + return *m.SteamidClan + } + return 0 +} + +func (m *CMsgClientAMGetClanOfficersResponse) GetOfficerCount() int32 { + if m != nil && m.OfficerCount != nil { + return *m.OfficerCount + } + return 0 +} + +type CMsgClientAMGetPersonaNameHistory struct { + IdCount *int32 `protobuf:"varint,1,opt,name=id_count" json:"id_count,omitempty"` + Ids []*CMsgClientAMGetPersonaNameHistory_IdInstance `protobuf:"bytes,2,rep,name=Ids" json:"Ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAMGetPersonaNameHistory) Reset() { *m = CMsgClientAMGetPersonaNameHistory{} } +func (m *CMsgClientAMGetPersonaNameHistory) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAMGetPersonaNameHistory) ProtoMessage() {} +func (*CMsgClientAMGetPersonaNameHistory) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{138} +} + +func (m *CMsgClientAMGetPersonaNameHistory) GetIdCount() int32 { + if m != nil && m.IdCount != nil { + return *m.IdCount + } + return 0 +} + +func (m *CMsgClientAMGetPersonaNameHistory) GetIds() []*CMsgClientAMGetPersonaNameHistory_IdInstance { + if m != nil { + return m.Ids + } + return nil +} + +type CMsgClientAMGetPersonaNameHistory_IdInstance struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAMGetPersonaNameHistory_IdInstance) Reset() { + *m = CMsgClientAMGetPersonaNameHistory_IdInstance{} +} +func (m *CMsgClientAMGetPersonaNameHistory_IdInstance) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientAMGetPersonaNameHistory_IdInstance) ProtoMessage() {} +func (*CMsgClientAMGetPersonaNameHistory_IdInstance) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{138, 0} +} + +func (m *CMsgClientAMGetPersonaNameHistory_IdInstance) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CMsgClientAMGetPersonaNameHistoryResponse struct { + Responses []*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance `protobuf:"bytes,2,rep,name=responses" json:"responses,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse) Reset() { + *m = CMsgClientAMGetPersonaNameHistoryResponse{} +} +func (m *CMsgClientAMGetPersonaNameHistoryResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAMGetPersonaNameHistoryResponse) ProtoMessage() {} +func (*CMsgClientAMGetPersonaNameHistoryResponse) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{139} +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse) GetResponses() []*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance { + if m != nil { + return m.Responses + } + return nil +} + +type CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Steamid *uint64 `protobuf:"fixed64,2,opt,name=steamid" json:"steamid,omitempty"` + Names []*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance `protobuf:"bytes,3,rep,name=names" json:"names,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance) Reset() { + *m = CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance{} +} +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance) ProtoMessage() {} +func (*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{139, 0} +} + +const Default_CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_Eresult int32 = 2 + +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_Eresult +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance) GetNames() []*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance { + if m != nil { + return m.Names + } + return nil +} + +type CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance struct { + NameSince *uint32 `protobuf:"fixed32,1,opt,name=name_since" json:"name_since,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance) Reset() { + *m = CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance{} +} +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance) ProtoMessage() {} +func (*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{139, 0, 0} +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance) GetNameSince() uint32 { + if m != nil && m.NameSince != nil { + return *m.NameSince + } + return 0 +} + +func (m *CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +type CMsgClientDeregisterWithServer struct { + Eservertype *uint32 `protobuf:"varint,1,opt,name=eservertype" json:"eservertype,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDeregisterWithServer) Reset() { *m = CMsgClientDeregisterWithServer{} } +func (m *CMsgClientDeregisterWithServer) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDeregisterWithServer) ProtoMessage() {} +func (*CMsgClientDeregisterWithServer) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{140} +} + +func (m *CMsgClientDeregisterWithServer) GetEservertype() uint32 { + if m != nil && m.Eservertype != nil { + return *m.Eservertype + } + return 0 +} + +func (m *CMsgClientDeregisterWithServer) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientClanState struct { + SteamidClan *uint64 `protobuf:"fixed64,1,opt,name=steamid_clan" json:"steamid_clan,omitempty"` + MUnStatusFlags *uint32 `protobuf:"varint,2,opt,name=m_unStatusFlags" json:"m_unStatusFlags,omitempty"` + ClanAccountFlags *uint32 `protobuf:"varint,3,opt,name=clan_account_flags" json:"clan_account_flags,omitempty"` + NameInfo *CMsgClientClanState_NameInfo `protobuf:"bytes,4,opt,name=name_info" json:"name_info,omitempty"` + UserCounts *CMsgClientClanState_UserCounts `protobuf:"bytes,5,opt,name=user_counts" json:"user_counts,omitempty"` + Events []*CMsgClientClanState_Event `protobuf:"bytes,6,rep,name=events" json:"events,omitempty"` + Announcements []*CMsgClientClanState_Event `protobuf:"bytes,7,rep,name=announcements" json:"announcements,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientClanState) Reset() { *m = CMsgClientClanState{} } +func (m *CMsgClientClanState) String() string { return proto.CompactTextString(m) } +func (*CMsgClientClanState) ProtoMessage() {} +func (*CMsgClientClanState) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{141} } + +func (m *CMsgClientClanState) GetSteamidClan() uint64 { + if m != nil && m.SteamidClan != nil { + return *m.SteamidClan + } + return 0 +} + +func (m *CMsgClientClanState) GetMUnStatusFlags() uint32 { + if m != nil && m.MUnStatusFlags != nil { + return *m.MUnStatusFlags + } + return 0 +} + +func (m *CMsgClientClanState) GetClanAccountFlags() uint32 { + if m != nil && m.ClanAccountFlags != nil { + return *m.ClanAccountFlags + } + return 0 +} + +func (m *CMsgClientClanState) GetNameInfo() *CMsgClientClanState_NameInfo { + if m != nil { + return m.NameInfo + } + return nil +} + +func (m *CMsgClientClanState) GetUserCounts() *CMsgClientClanState_UserCounts { + if m != nil { + return m.UserCounts + } + return nil +} + +func (m *CMsgClientClanState) GetEvents() []*CMsgClientClanState_Event { + if m != nil { + return m.Events + } + return nil +} + +func (m *CMsgClientClanState) GetAnnouncements() []*CMsgClientClanState_Event { + if m != nil { + return m.Announcements + } + return nil +} + +type CMsgClientClanState_NameInfo struct { + ClanName *string `protobuf:"bytes,1,opt,name=clan_name" json:"clan_name,omitempty"` + ShaAvatar []byte `protobuf:"bytes,2,opt,name=sha_avatar" json:"sha_avatar,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientClanState_NameInfo) Reset() { *m = CMsgClientClanState_NameInfo{} } +func (m *CMsgClientClanState_NameInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientClanState_NameInfo) ProtoMessage() {} +func (*CMsgClientClanState_NameInfo) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{141, 0} +} + +func (m *CMsgClientClanState_NameInfo) GetClanName() string { + if m != nil && m.ClanName != nil { + return *m.ClanName + } + return "" +} + +func (m *CMsgClientClanState_NameInfo) GetShaAvatar() []byte { + if m != nil { + return m.ShaAvatar + } + return nil +} + +type CMsgClientClanState_UserCounts struct { + Members *uint32 `protobuf:"varint,1,opt,name=members" json:"members,omitempty"` + Online *uint32 `protobuf:"varint,2,opt,name=online" json:"online,omitempty"` + Chatting *uint32 `protobuf:"varint,3,opt,name=chatting" json:"chatting,omitempty"` + InGame *uint32 `protobuf:"varint,4,opt,name=in_game" json:"in_game,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientClanState_UserCounts) Reset() { *m = CMsgClientClanState_UserCounts{} } +func (m *CMsgClientClanState_UserCounts) String() string { return proto.CompactTextString(m) } +func (*CMsgClientClanState_UserCounts) ProtoMessage() {} +func (*CMsgClientClanState_UserCounts) Descriptor() ([]byte, []int) { + return client_server_fileDescriptor0, []int{141, 1} +} + +func (m *CMsgClientClanState_UserCounts) GetMembers() uint32 { + if m != nil && m.Members != nil { + return *m.Members + } + return 0 +} + +func (m *CMsgClientClanState_UserCounts) GetOnline() uint32 { + if m != nil && m.Online != nil { + return *m.Online + } + return 0 +} + +func (m *CMsgClientClanState_UserCounts) GetChatting() uint32 { + if m != nil && m.Chatting != nil { + return *m.Chatting + } + return 0 +} + +func (m *CMsgClientClanState_UserCounts) GetInGame() uint32 { + if m != nil && m.InGame != nil { + return *m.InGame + } + return 0 +} + +type CMsgClientClanState_Event struct { + Gid *uint64 `protobuf:"fixed64,1,opt,name=gid" json:"gid,omitempty"` + EventTime *uint32 `protobuf:"varint,2,opt,name=event_time" json:"event_time,omitempty"` + Headline *string `protobuf:"bytes,3,opt,name=headline" json:"headline,omitempty"` + GameId *uint64 `protobuf:"fixed64,4,opt,name=game_id" json:"game_id,omitempty"` + JustPosted *bool `protobuf:"varint,5,opt,name=just_posted" json:"just_posted,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientClanState_Event) Reset() { *m = CMsgClientClanState_Event{} } +func (m *CMsgClientClanState_Event) String() string { return proto.CompactTextString(m) } +func (*CMsgClientClanState_Event) ProtoMessage() {} +func (*CMsgClientClanState_Event) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{141, 2} } + +func (m *CMsgClientClanState_Event) GetGid() uint64 { + if m != nil && m.Gid != nil { + return *m.Gid + } + return 0 +} + +func (m *CMsgClientClanState_Event) GetEventTime() uint32 { + if m != nil && m.EventTime != nil { + return *m.EventTime + } + return 0 +} + +func (m *CMsgClientClanState_Event) GetHeadline() string { + if m != nil && m.Headline != nil { + return *m.Headline + } + return "" +} + +func (m *CMsgClientClanState_Event) GetGameId() uint64 { + if m != nil && m.GameId != nil { + return *m.GameId + } + return 0 +} + +func (m *CMsgClientClanState_Event) GetJustPosted() bool { + if m != nil && m.JustPosted != nil { + return *m.JustPosted + } + return false +} + +type CMsgClientFriendMsg struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + ChatEntryType *int32 `protobuf:"varint,2,opt,name=chat_entry_type" json:"chat_entry_type,omitempty"` + Message []byte `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"` + Rtime32ServerTimestamp *uint32 `protobuf:"fixed32,4,opt,name=rtime32_server_timestamp" json:"rtime32_server_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendMsg) Reset() { *m = CMsgClientFriendMsg{} } +func (m *CMsgClientFriendMsg) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendMsg) ProtoMessage() {} +func (*CMsgClientFriendMsg) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{142} } + +func (m *CMsgClientFriendMsg) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgClientFriendMsg) GetChatEntryType() int32 { + if m != nil && m.ChatEntryType != nil { + return *m.ChatEntryType + } + return 0 +} + +func (m *CMsgClientFriendMsg) GetMessage() []byte { + if m != nil { + return m.Message + } + return nil +} + +func (m *CMsgClientFriendMsg) GetRtime32ServerTimestamp() uint32 { + if m != nil && m.Rtime32ServerTimestamp != nil { + return *m.Rtime32ServerTimestamp + } + return 0 +} + +type CMsgClientFriendMsgIncoming struct { + SteamidFrom *uint64 `protobuf:"fixed64,1,opt,name=steamid_from" json:"steamid_from,omitempty"` + ChatEntryType *int32 `protobuf:"varint,2,opt,name=chat_entry_type" json:"chat_entry_type,omitempty"` + FromLimitedAccount *bool `protobuf:"varint,3,opt,name=from_limited_account" json:"from_limited_account,omitempty"` + Message []byte `protobuf:"bytes,4,opt,name=message" json:"message,omitempty"` + Rtime32ServerTimestamp *uint32 `protobuf:"fixed32,5,opt,name=rtime32_server_timestamp" json:"rtime32_server_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendMsgIncoming) Reset() { *m = CMsgClientFriendMsgIncoming{} } +func (m *CMsgClientFriendMsgIncoming) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendMsgIncoming) ProtoMessage() {} +func (*CMsgClientFriendMsgIncoming) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{143} } + +func (m *CMsgClientFriendMsgIncoming) GetSteamidFrom() uint64 { + if m != nil && m.SteamidFrom != nil { + return *m.SteamidFrom + } + return 0 +} + +func (m *CMsgClientFriendMsgIncoming) GetChatEntryType() int32 { + if m != nil && m.ChatEntryType != nil { + return *m.ChatEntryType + } + return 0 +} + +func (m *CMsgClientFriendMsgIncoming) GetFromLimitedAccount() bool { + if m != nil && m.FromLimitedAccount != nil { + return *m.FromLimitedAccount + } + return false +} + +func (m *CMsgClientFriendMsgIncoming) GetMessage() []byte { + if m != nil { + return m.Message + } + return nil +} + +func (m *CMsgClientFriendMsgIncoming) GetRtime32ServerTimestamp() uint32 { + if m != nil && m.Rtime32ServerTimestamp != nil { + return *m.Rtime32ServerTimestamp + } + return 0 +} + +type CMsgClientAddFriend struct { + SteamidToAdd *uint64 `protobuf:"fixed64,1,opt,name=steamid_to_add" json:"steamid_to_add,omitempty"` + AccountnameOrEmailToAdd *string `protobuf:"bytes,2,opt,name=accountname_or_email_to_add" json:"accountname_or_email_to_add,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAddFriend) Reset() { *m = CMsgClientAddFriend{} } +func (m *CMsgClientAddFriend) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAddFriend) ProtoMessage() {} +func (*CMsgClientAddFriend) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{144} } + +func (m *CMsgClientAddFriend) GetSteamidToAdd() uint64 { + if m != nil && m.SteamidToAdd != nil { + return *m.SteamidToAdd + } + return 0 +} + +func (m *CMsgClientAddFriend) GetAccountnameOrEmailToAdd() string { + if m != nil && m.AccountnameOrEmailToAdd != nil { + return *m.AccountnameOrEmailToAdd + } + return "" +} + +type CMsgClientAddFriendResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + SteamIdAdded *uint64 `protobuf:"fixed64,2,opt,name=steam_id_added" json:"steam_id_added,omitempty"` + PersonaNameAdded *string `protobuf:"bytes,3,opt,name=persona_name_added" json:"persona_name_added,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAddFriendResponse) Reset() { *m = CMsgClientAddFriendResponse{} } +func (m *CMsgClientAddFriendResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAddFriendResponse) ProtoMessage() {} +func (*CMsgClientAddFriendResponse) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{145} } + +const Default_CMsgClientAddFriendResponse_Eresult int32 = 2 + +func (m *CMsgClientAddFriendResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientAddFriendResponse_Eresult +} + +func (m *CMsgClientAddFriendResponse) GetSteamIdAdded() uint64 { + if m != nil && m.SteamIdAdded != nil { + return *m.SteamIdAdded + } + return 0 +} + +func (m *CMsgClientAddFriendResponse) GetPersonaNameAdded() string { + if m != nil && m.PersonaNameAdded != nil { + return *m.PersonaNameAdded + } + return "" +} + +type CMsgClientRemoveFriend struct { + Friendid *uint64 `protobuf:"fixed64,1,opt,name=friendid" json:"friendid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRemoveFriend) Reset() { *m = CMsgClientRemoveFriend{} } +func (m *CMsgClientRemoveFriend) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRemoveFriend) ProtoMessage() {} +func (*CMsgClientRemoveFriend) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{146} } + +func (m *CMsgClientRemoveFriend) GetFriendid() uint64 { + if m != nil && m.Friendid != nil { + return *m.Friendid + } + return 0 +} + +type CMsgClientHideFriend struct { + Friendid *uint64 `protobuf:"fixed64,1,opt,name=friendid" json:"friendid,omitempty"` + Hide *bool `protobuf:"varint,2,opt,name=hide" json:"hide,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientHideFriend) Reset() { *m = CMsgClientHideFriend{} } +func (m *CMsgClientHideFriend) String() string { return proto.CompactTextString(m) } +func (*CMsgClientHideFriend) ProtoMessage() {} +func (*CMsgClientHideFriend) Descriptor() ([]byte, []int) { return client_server_fileDescriptor0, []int{147} } + +func (m *CMsgClientHideFriend) GetFriendid() uint64 { + if m != nil && m.Friendid != nil { + return *m.Friendid + } + return 0 +} + +func (m *CMsgClientHideFriend) GetHide() bool { + if m != nil && m.Hide != nil { + return *m.Hide + } + return false +} + +func init() { + proto.RegisterType((*CMsgClientHeartBeat)(nil), "CMsgClientHeartBeat") + proto.RegisterType((*CMsgClientUDSP2PSessionStarted)(nil), "CMsgClientUDSP2PSessionStarted") + proto.RegisterType((*CMsgClientUDSP2PSessionEnded)(nil), "CMsgClientUDSP2PSessionEnded") + proto.RegisterType((*CMsgClientRegisterAuthTicketWithCM)(nil), "CMsgClientRegisterAuthTicketWithCM") + proto.RegisterType((*CMsgClientTicketAuthComplete)(nil), "CMsgClientTicketAuthComplete") + proto.RegisterType((*CMsgClientLogon)(nil), "CMsgClientLogon") + proto.RegisterType((*CMsgClientLogonResponse)(nil), "CMsgClientLogonResponse") + proto.RegisterType((*CMsgClientRequestWebAPIAuthenticateUserNonce)(nil), "CMsgClientRequestWebAPIAuthenticateUserNonce") + proto.RegisterType((*CMsgClientRequestWebAPIAuthenticateUserNonceResponse)(nil), "CMsgClientRequestWebAPIAuthenticateUserNonceResponse") + proto.RegisterType((*CMsgClientLogOff)(nil), "CMsgClientLogOff") + proto.RegisterType((*CMsgClientLoggedOff)(nil), "CMsgClientLoggedOff") + proto.RegisterType((*CMsgClientCMList)(nil), "CMsgClientCMList") + proto.RegisterType((*CMsgClientP2PConnectionInfo)(nil), "CMsgClientP2PConnectionInfo") + proto.RegisterType((*CMsgClientP2PConnectionFailInfo)(nil), "CMsgClientP2PConnectionFailInfo") + proto.RegisterType((*CMsgClientGetAppOwnershipTicket)(nil), "CMsgClientGetAppOwnershipTicket") + proto.RegisterType((*CMsgClientGetAppOwnershipTicketResponse)(nil), "CMsgClientGetAppOwnershipTicketResponse") + proto.RegisterType((*CMsgClientSessionToken)(nil), "CMsgClientSessionToken") + proto.RegisterType((*CMsgClientGameConnectTokens)(nil), "CMsgClientGameConnectTokens") + proto.RegisterType((*CMsgGSServerType)(nil), "CMsgGSServerType") + proto.RegisterType((*CMsgGSStatusReply)(nil), "CMsgGSStatusReply") + proto.RegisterType((*CMsgGSPlayerList)(nil), "CMsgGSPlayerList") + proto.RegisterType((*CMsgGSPlayerList_Player)(nil), "CMsgGSPlayerList.Player") + proto.RegisterType((*CMsgGSUserPlaying)(nil), "CMsgGSUserPlaying") + proto.RegisterType((*CMsgGSDisconnectNotice)(nil), "CMsgGSDisconnectNotice") + proto.RegisterType((*CMsgClientGamesPlayed)(nil), "CMsgClientGamesPlayed") + proto.RegisterType((*CMsgClientGamesPlayed_GamePlayed)(nil), "CMsgClientGamesPlayed.GamePlayed") + proto.RegisterType((*CMsgGSApprove)(nil), "CMsgGSApprove") + proto.RegisterType((*CMsgGSDeny)(nil), "CMsgGSDeny") + proto.RegisterType((*CMsgGSKick)(nil), "CMsgGSKick") + proto.RegisterType((*CMsgClientAuthList)(nil), "CMsgClientAuthList") + proto.RegisterType((*CMsgClientAuthListAck)(nil), "CMsgClientAuthListAck") + proto.RegisterType((*CMsgClientFriendsList)(nil), "CMsgClientFriendsList") + proto.RegisterType((*CMsgClientFriendsList_Friend)(nil), "CMsgClientFriendsList.Friend") + proto.RegisterType((*CMsgClientFriendsGroupsList)(nil), "CMsgClientFriendsGroupsList") + proto.RegisterType((*CMsgClientFriendsGroupsList_FriendGroup)(nil), "CMsgClientFriendsGroupsList.FriendGroup") + proto.RegisterType((*CMsgClientFriendsGroupsList_FriendGroupsMembership)(nil), "CMsgClientFriendsGroupsList.FriendGroupsMembership") + proto.RegisterType((*CMsgClientPlayerNicknameList)(nil), "CMsgClientPlayerNicknameList") + proto.RegisterType((*CMsgClientPlayerNicknameList_PlayerNickname)(nil), "CMsgClientPlayerNicknameList.PlayerNickname") + proto.RegisterType((*CMsgClientSetPlayerNickname)(nil), "CMsgClientSetPlayerNickname") + proto.RegisterType((*CMsgClientSetPlayerNicknameResponse)(nil), "CMsgClientSetPlayerNicknameResponse") + proto.RegisterType((*CMsgClientLicenseList)(nil), "CMsgClientLicenseList") + proto.RegisterType((*CMsgClientLicenseList_License)(nil), "CMsgClientLicenseList.License") + proto.RegisterType((*CMsgClientLBSSetScore)(nil), "CMsgClientLBSSetScore") + proto.RegisterType((*CMsgClientLBSSetScoreResponse)(nil), "CMsgClientLBSSetScoreResponse") + proto.RegisterType((*CMsgClientLBSSetUGC)(nil), "CMsgClientLBSSetUGC") + proto.RegisterType((*CMsgClientLBSSetUGCResponse)(nil), "CMsgClientLBSSetUGCResponse") + proto.RegisterType((*CMsgClientLBSFindOrCreateLB)(nil), "CMsgClientLBSFindOrCreateLB") + proto.RegisterType((*CMsgClientLBSFindOrCreateLBResponse)(nil), "CMsgClientLBSFindOrCreateLBResponse") + proto.RegisterType((*CMsgClientLBSGetLBEntries)(nil), "CMsgClientLBSGetLBEntries") + proto.RegisterType((*CMsgClientLBSGetLBEntriesResponse)(nil), "CMsgClientLBSGetLBEntriesResponse") + proto.RegisterType((*CMsgClientLBSGetLBEntriesResponse_Entry)(nil), "CMsgClientLBSGetLBEntriesResponse.Entry") + proto.RegisterType((*CMsgClientAccountInfo)(nil), "CMsgClientAccountInfo") + proto.RegisterType((*CMsgClientAppMinutesPlayedData)(nil), "CMsgClientAppMinutesPlayedData") + proto.RegisterType((*CMsgClientAppMinutesPlayedData_AppMinutesPlayedData)(nil), "CMsgClientAppMinutesPlayedData.AppMinutesPlayedData") + proto.RegisterType((*CMsgClientIsLimitedAccount)(nil), "CMsgClientIsLimitedAccount") + proto.RegisterType((*CMsgClientRequestFriendData)(nil), "CMsgClientRequestFriendData") + proto.RegisterType((*CMsgClientChangeStatus)(nil), "CMsgClientChangeStatus") + proto.RegisterType((*CMsgPersonaChangeResponse)(nil), "CMsgPersonaChangeResponse") + proto.RegisterType((*CMsgClientPersonaState)(nil), "CMsgClientPersonaState") + proto.RegisterType((*CMsgClientPersonaState_Friend)(nil), "CMsgClientPersonaState.Friend") + proto.RegisterType((*CMsgClientFriendProfileInfo)(nil), "CMsgClientFriendProfileInfo") + proto.RegisterType((*CMsgClientFriendProfileInfoResponse)(nil), "CMsgClientFriendProfileInfoResponse") + proto.RegisterType((*CMsgClientServerList)(nil), "CMsgClientServerList") + proto.RegisterType((*CMsgClientServerList_Server)(nil), "CMsgClientServerList.Server") + proto.RegisterType((*CMsgClientRequestedClientStats)(nil), "CMsgClientRequestedClientStats") + proto.RegisterType((*CMsgClientRequestedClientStats_StatsToSend)(nil), "CMsgClientRequestedClientStats.StatsToSend") + proto.RegisterType((*CMsgClientStat2)(nil), "CMsgClientStat2") + proto.RegisterType((*CMsgClientStat2_StatDetail)(nil), "CMsgClientStat2.StatDetail") + proto.RegisterType((*CMsgClientMMSCreateLobby)(nil), "CMsgClientMMSCreateLobby") + proto.RegisterType((*CMsgClientMMSCreateLobbyResponse)(nil), "CMsgClientMMSCreateLobbyResponse") + proto.RegisterType((*CMsgClientMMSJoinLobby)(nil), "CMsgClientMMSJoinLobby") + proto.RegisterType((*CMsgClientMMSJoinLobbyResponse)(nil), "CMsgClientMMSJoinLobbyResponse") + proto.RegisterType((*CMsgClientMMSJoinLobbyResponse_Member)(nil), "CMsgClientMMSJoinLobbyResponse.Member") + proto.RegisterType((*CMsgClientMMSLeaveLobby)(nil), "CMsgClientMMSLeaveLobby") + proto.RegisterType((*CMsgClientMMSLeaveLobbyResponse)(nil), "CMsgClientMMSLeaveLobbyResponse") + proto.RegisterType((*CMsgClientMMSGetLobbyList)(nil), "CMsgClientMMSGetLobbyList") + proto.RegisterType((*CMsgClientMMSGetLobbyList_Filter)(nil), "CMsgClientMMSGetLobbyList.Filter") + proto.RegisterType((*CMsgClientMMSGetLobbyListResponse)(nil), "CMsgClientMMSGetLobbyListResponse") + proto.RegisterType((*CMsgClientMMSGetLobbyListResponse_Lobby)(nil), "CMsgClientMMSGetLobbyListResponse.Lobby") + proto.RegisterType((*CMsgClientMMSSetLobbyData)(nil), "CMsgClientMMSSetLobbyData") + proto.RegisterType((*CMsgClientMMSSetLobbyDataResponse)(nil), "CMsgClientMMSSetLobbyDataResponse") + proto.RegisterType((*CMsgClientMMSGetLobbyData)(nil), "CMsgClientMMSGetLobbyData") + proto.RegisterType((*CMsgClientMMSLobbyData)(nil), "CMsgClientMMSLobbyData") + proto.RegisterType((*CMsgClientMMSLobbyData_Member)(nil), "CMsgClientMMSLobbyData.Member") + proto.RegisterType((*CMsgClientMMSSendLobbyChatMsg)(nil), "CMsgClientMMSSendLobbyChatMsg") + proto.RegisterType((*CMsgClientMMSLobbyChatMsg)(nil), "CMsgClientMMSLobbyChatMsg") + proto.RegisterType((*CMsgClientMMSSetLobbyOwner)(nil), "CMsgClientMMSSetLobbyOwner") + proto.RegisterType((*CMsgClientMMSSetLobbyOwnerResponse)(nil), "CMsgClientMMSSetLobbyOwnerResponse") + proto.RegisterType((*CMsgClientMMSSetLobbyLinked)(nil), "CMsgClientMMSSetLobbyLinked") + proto.RegisterType((*CMsgClientMMSSetLobbyGameServer)(nil), "CMsgClientMMSSetLobbyGameServer") + proto.RegisterType((*CMsgClientMMSLobbyGameServerSet)(nil), "CMsgClientMMSLobbyGameServerSet") + proto.RegisterType((*CMsgClientMMSUserJoinedLobby)(nil), "CMsgClientMMSUserJoinedLobby") + proto.RegisterType((*CMsgClientMMSUserLeftLobby)(nil), "CMsgClientMMSUserLeftLobby") + proto.RegisterType((*CMsgClientMMSInviteToLobby)(nil), "CMsgClientMMSInviteToLobby") + proto.RegisterType((*CMsgClientUDSInviteToGame)(nil), "CMsgClientUDSInviteToGame") + proto.RegisterType((*CMsgClientChatInvite)(nil), "CMsgClientChatInvite") + proto.RegisterType((*CMsgClientConnectionStats)(nil), "CMsgClientConnectionStats") + proto.RegisterType((*CMsgClientConnectionStats_Stats_Logon)(nil), "CMsgClientConnectionStats.Stats_Logon") + proto.RegisterType((*CMsgClientConnectionStats_Stats_UDP)(nil), "CMsgClientConnectionStats.Stats_UDP") + proto.RegisterType((*CMsgClientConnectionStats_Stats_VConn)(nil), "CMsgClientConnectionStats.Stats_VConn") + proto.RegisterType((*CMsgClientServersAvailable)(nil), "CMsgClientServersAvailable") + proto.RegisterType((*CMsgClientServersAvailable_Server_Types_Available)(nil), "CMsgClientServersAvailable.Server_Types_Available") + proto.RegisterType((*CMsgClientGetUserStats)(nil), "CMsgClientGetUserStats") + proto.RegisterType((*CMsgClientGetUserStatsResponse)(nil), "CMsgClientGetUserStatsResponse") + proto.RegisterType((*CMsgClientGetUserStatsResponse_Stats)(nil), "CMsgClientGetUserStatsResponse.Stats") + proto.RegisterType((*CMsgClientGetUserStatsResponse_Achievement_Blocks)(nil), "CMsgClientGetUserStatsResponse.Achievement_Blocks") + proto.RegisterType((*CMsgClientStoreUserStatsResponse)(nil), "CMsgClientStoreUserStatsResponse") + proto.RegisterType((*CMsgClientStoreUserStatsResponse_Stats_Failed_Validation)(nil), "CMsgClientStoreUserStatsResponse.Stats_Failed_Validation") + proto.RegisterType((*CMsgClientStoreUserStats2)(nil), "CMsgClientStoreUserStats2") + proto.RegisterType((*CMsgClientStoreUserStats2_Stats)(nil), "CMsgClientStoreUserStats2.Stats") + proto.RegisterType((*CMsgClientStatsUpdated)(nil), "CMsgClientStatsUpdated") + proto.RegisterType((*CMsgClientStatsUpdated_Updated_Stats)(nil), "CMsgClientStatsUpdated.Updated_Stats") + proto.RegisterType((*CMsgClientStoreUserStats)(nil), "CMsgClientStoreUserStats") + proto.RegisterType((*CMsgClientStoreUserStats_Stats_To_Store)(nil), "CMsgClientStoreUserStats.Stats_To_Store") + proto.RegisterType((*CMsgClientGetClientDetails)(nil), "CMsgClientGetClientDetails") + proto.RegisterType((*CMsgClientReportOverlayDetourFailure)(nil), "CMsgClientReportOverlayDetourFailure") + proto.RegisterType((*CMsgClientGetClientDetailsResponse)(nil), "CMsgClientGetClientDetailsResponse") + proto.RegisterType((*CMsgClientGetClientDetailsResponse_Game)(nil), "CMsgClientGetClientDetailsResponse.Game") + proto.RegisterType((*CMsgClientGetClientAppList)(nil), "CMsgClientGetClientAppList") + proto.RegisterType((*CMsgClientGetClientAppListResponse)(nil), "CMsgClientGetClientAppListResponse") + proto.RegisterType((*CMsgClientGetClientAppListResponse_App)(nil), "CMsgClientGetClientAppListResponse.App") + proto.RegisterType((*CMsgClientGetClientAppListResponse_App_DLC)(nil), "CMsgClientGetClientAppListResponse.App.DLC") + proto.RegisterType((*CMsgClientInstallClientApp)(nil), "CMsgClientInstallClientApp") + proto.RegisterType((*CMsgClientInstallClientAppResponse)(nil), "CMsgClientInstallClientAppResponse") + proto.RegisterType((*CMsgClientUninstallClientApp)(nil), "CMsgClientUninstallClientApp") + proto.RegisterType((*CMsgClientUninstallClientAppResponse)(nil), "CMsgClientUninstallClientAppResponse") + proto.RegisterType((*CMsgClientSetClientAppUpdateState)(nil), "CMsgClientSetClientAppUpdateState") + proto.RegisterType((*CMsgClientSetClientAppUpdateStateResponse)(nil), "CMsgClientSetClientAppUpdateStateResponse") + proto.RegisterType((*CMsgClientUFSUploadFileRequest)(nil), "CMsgClientUFSUploadFileRequest") + proto.RegisterType((*CMsgClientUFSUploadFileResponse)(nil), "CMsgClientUFSUploadFileResponse") + proto.RegisterType((*CMsgClientUFSUploadCommit)(nil), "CMsgClientUFSUploadCommit") + proto.RegisterType((*CMsgClientUFSUploadCommit_File)(nil), "CMsgClientUFSUploadCommit.File") + proto.RegisterType((*CMsgClientUFSUploadCommitResponse)(nil), "CMsgClientUFSUploadCommitResponse") + proto.RegisterType((*CMsgClientUFSUploadCommitResponse_File)(nil), "CMsgClientUFSUploadCommitResponse.File") + proto.RegisterType((*CMsgClientUFSFileChunk)(nil), "CMsgClientUFSFileChunk") + proto.RegisterType((*CMsgClientUFSTransferHeartbeat)(nil), "CMsgClientUFSTransferHeartbeat") + proto.RegisterType((*CMsgClientUFSUploadFileFinished)(nil), "CMsgClientUFSUploadFileFinished") + proto.RegisterType((*CMsgClientUFSDeleteFileRequest)(nil), "CMsgClientUFSDeleteFileRequest") + proto.RegisterType((*CMsgClientUFSDeleteFileResponse)(nil), "CMsgClientUFSDeleteFileResponse") + proto.RegisterType((*CMsgClientUFSGetFileListForApp)(nil), "CMsgClientUFSGetFileListForApp") + proto.RegisterType((*CMsgClientUFSGetFileListForAppResponse)(nil), "CMsgClientUFSGetFileListForAppResponse") + proto.RegisterType((*CMsgClientUFSGetFileListForAppResponse_File)(nil), "CMsgClientUFSGetFileListForAppResponse.File") + proto.RegisterType((*CMsgClientUFSDownloadRequest)(nil), "CMsgClientUFSDownloadRequest") + proto.RegisterType((*CMsgClientUFSDownloadResponse)(nil), "CMsgClientUFSDownloadResponse") + proto.RegisterType((*CMsgClientUFSLoginRequest)(nil), "CMsgClientUFSLoginRequest") + proto.RegisterType((*CMsgClientUFSLoginResponse)(nil), "CMsgClientUFSLoginResponse") + proto.RegisterType((*CMsgClientRequestEncryptedAppTicket)(nil), "CMsgClientRequestEncryptedAppTicket") + proto.RegisterType((*CMsgClientRequestEncryptedAppTicketResponse)(nil), "CMsgClientRequestEncryptedAppTicketResponse") + proto.RegisterType((*CMsgClientWalletInfoUpdate)(nil), "CMsgClientWalletInfoUpdate") + proto.RegisterType((*CMsgClientAppInfoUpdate)(nil), "CMsgClientAppInfoUpdate") + proto.RegisterType((*CMsgClientAppInfoChanges)(nil), "CMsgClientAppInfoChanges") + proto.RegisterType((*CMsgClientAppInfoRequest)(nil), "CMsgClientAppInfoRequest") + proto.RegisterType((*CMsgClientAppInfoRequest_App)(nil), "CMsgClientAppInfoRequest.App") + proto.RegisterType((*CMsgClientAppInfoResponse)(nil), "CMsgClientAppInfoResponse") + proto.RegisterType((*CMsgClientAppInfoResponse_App)(nil), "CMsgClientAppInfoResponse.App") + proto.RegisterType((*CMsgClientAppInfoResponse_App_Section)(nil), "CMsgClientAppInfoResponse.App.Section") + proto.RegisterType((*CMsgClientPackageInfoRequest)(nil), "CMsgClientPackageInfoRequest") + proto.RegisterType((*CMsgClientPackageInfoResponse)(nil), "CMsgClientPackageInfoResponse") + proto.RegisterType((*CMsgClientPackageInfoResponse_Package)(nil), "CMsgClientPackageInfoResponse.Package") + proto.RegisterType((*CMsgClientPICSChangesSinceRequest)(nil), "CMsgClientPICSChangesSinceRequest") + proto.RegisterType((*CMsgClientPICSChangesSinceResponse)(nil), "CMsgClientPICSChangesSinceResponse") + proto.RegisterType((*CMsgClientPICSChangesSinceResponse_PackageChange)(nil), "CMsgClientPICSChangesSinceResponse.PackageChange") + proto.RegisterType((*CMsgClientPICSChangesSinceResponse_AppChange)(nil), "CMsgClientPICSChangesSinceResponse.AppChange") + proto.RegisterType((*CMsgClientPICSProductInfoRequest)(nil), "CMsgClientPICSProductInfoRequest") + proto.RegisterType((*CMsgClientPICSProductInfoRequest_AppInfo)(nil), "CMsgClientPICSProductInfoRequest.AppInfo") + proto.RegisterType((*CMsgClientPICSProductInfoRequest_PackageInfo)(nil), "CMsgClientPICSProductInfoRequest.PackageInfo") + proto.RegisterType((*CMsgClientPICSProductInfoResponse)(nil), "CMsgClientPICSProductInfoResponse") + proto.RegisterType((*CMsgClientPICSProductInfoResponse_AppInfo)(nil), "CMsgClientPICSProductInfoResponse.AppInfo") + proto.RegisterType((*CMsgClientPICSProductInfoResponse_PackageInfo)(nil), "CMsgClientPICSProductInfoResponse.PackageInfo") + proto.RegisterType((*CMsgClientPICSAccessTokenRequest)(nil), "CMsgClientPICSAccessTokenRequest") + proto.RegisterType((*CMsgClientPICSAccessTokenResponse)(nil), "CMsgClientPICSAccessTokenResponse") + proto.RegisterType((*CMsgClientPICSAccessTokenResponse_PackageToken)(nil), "CMsgClientPICSAccessTokenResponse.PackageToken") + proto.RegisterType((*CMsgClientPICSAccessTokenResponse_AppToken)(nil), "CMsgClientPICSAccessTokenResponse.AppToken") + proto.RegisterType((*CMsgClientUFSGetUGCDetails)(nil), "CMsgClientUFSGetUGCDetails") + proto.RegisterType((*CMsgClientUFSGetUGCDetailsResponse)(nil), "CMsgClientUFSGetUGCDetailsResponse") + proto.RegisterType((*CMsgClientUFSGetSingleFileInfo)(nil), "CMsgClientUFSGetSingleFileInfo") + proto.RegisterType((*CMsgClientUFSGetSingleFileInfoResponse)(nil), "CMsgClientUFSGetSingleFileInfoResponse") + proto.RegisterType((*CMsgClientUFSShareFile)(nil), "CMsgClientUFSShareFile") + proto.RegisterType((*CMsgClientUFSShareFileResponse)(nil), "CMsgClientUFSShareFileResponse") + proto.RegisterType((*CMsgClientNewLoginKey)(nil), "CMsgClientNewLoginKey") + proto.RegisterType((*CMsgClientNewLoginKeyAccepted)(nil), "CMsgClientNewLoginKeyAccepted") + proto.RegisterType((*CMsgClientAMGetClanOfficers)(nil), "CMsgClientAMGetClanOfficers") + proto.RegisterType((*CMsgClientAMGetClanOfficersResponse)(nil), "CMsgClientAMGetClanOfficersResponse") + proto.RegisterType((*CMsgClientAMGetPersonaNameHistory)(nil), "CMsgClientAMGetPersonaNameHistory") + proto.RegisterType((*CMsgClientAMGetPersonaNameHistory_IdInstance)(nil), "CMsgClientAMGetPersonaNameHistory.IdInstance") + proto.RegisterType((*CMsgClientAMGetPersonaNameHistoryResponse)(nil), "CMsgClientAMGetPersonaNameHistoryResponse") + proto.RegisterType((*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance)(nil), "CMsgClientAMGetPersonaNameHistoryResponse.NameTableInstance") + proto.RegisterType((*CMsgClientAMGetPersonaNameHistoryResponse_NameTableInstance_NameInstance)(nil), "CMsgClientAMGetPersonaNameHistoryResponse.NameTableInstance.NameInstance") + proto.RegisterType((*CMsgClientDeregisterWithServer)(nil), "CMsgClientDeregisterWithServer") + proto.RegisterType((*CMsgClientClanState)(nil), "CMsgClientClanState") + proto.RegisterType((*CMsgClientClanState_NameInfo)(nil), "CMsgClientClanState.NameInfo") + proto.RegisterType((*CMsgClientClanState_UserCounts)(nil), "CMsgClientClanState.UserCounts") + proto.RegisterType((*CMsgClientClanState_Event)(nil), "CMsgClientClanState.Event") + proto.RegisterType((*CMsgClientFriendMsg)(nil), "CMsgClientFriendMsg") + proto.RegisterType((*CMsgClientFriendMsgIncoming)(nil), "CMsgClientFriendMsgIncoming") + proto.RegisterType((*CMsgClientAddFriend)(nil), "CMsgClientAddFriend") + proto.RegisterType((*CMsgClientAddFriendResponse)(nil), "CMsgClientAddFriendResponse") + proto.RegisterType((*CMsgClientRemoveFriend)(nil), "CMsgClientRemoveFriend") + proto.RegisterType((*CMsgClientHideFriend)(nil), "CMsgClientHideFriend") +} + +var client_server_fileDescriptor0 = []byte{ + // 8079 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x7c, 0x5b, 0x8c, 0x1c, 0xc7, + 0x75, 0xa8, 0xe7, 0xb5, 0x8f, 0xda, 0x5d, 0x91, 0x1c, 0x51, 0xe4, 0x70, 0x24, 0x52, 0x54, 0xeb, + 0x65, 0x89, 0xd2, 0x88, 0x5c, 0xf1, 0x21, 0xca, 0xf2, 0x95, 0x97, 0xcb, 0x87, 0x68, 0xf3, 0x65, + 0x2e, 0x29, 0x19, 0xbe, 0x96, 0x5b, 0xbd, 0xdd, 0x35, 0x33, 0xed, 0xed, 0xe9, 0x1e, 0x75, 0xf7, + 0xec, 0x6a, 0xed, 0xfb, 0xe1, 0x7b, 0x71, 0xaf, 0x71, 0x61, 0x18, 0x17, 0xf7, 0xfe, 0x5d, 0x3b, + 0x08, 0x62, 0x04, 0x30, 0x0c, 0x24, 0x41, 0xfe, 0x1c, 0x38, 0x4e, 0x02, 0xe7, 0x89, 0x04, 0xf9, + 0x09, 0x12, 0x20, 0x3f, 0x01, 0x82, 0xe4, 0xc7, 0x48, 0x90, 0xcf, 0x00, 0x01, 0xfc, 0x13, 0x20, + 0xe7, 0x51, 0xd5, 0x5d, 0xdd, 0xd3, 0xb3, 0xbb, 0xb4, 0x14, 0xff, 0x90, 0x3b, 0xd5, 0x55, 0xa7, + 0x4e, 0x9d, 0x57, 0x9d, 0x73, 0xea, 0x54, 0x89, 0xd3, 0x49, 0x2a, 0x9d, 0xd1, 0x48, 0x26, 0x89, + 0x33, 0x90, 0x89, 0xed, 0x06, 0xbe, 0x0c, 0xd3, 0x44, 0xc6, 0xdb, 0x32, 0xee, 0x8d, 0xe3, 0x28, + 0x8d, 0xba, 0x9d, 0x62, 0x8f, 0x4d, 0x27, 0x91, 0xea, 0x4b, 0x57, 0x86, 0x6e, 0xbc, 0x3b, 0x4e, + 0xa5, 0x67, 0x3b, 0xe3, 0xb1, 0x9d, 0xfa, 0xee, 0x96, 0x4c, 0xf9, 0x9b, 0xf5, 0x84, 0x78, 0x7c, + 0xfd, 0x76, 0x32, 0x58, 0x27, 0x78, 0xef, 0x48, 0x27, 0x4e, 0xaf, 0x48, 0x27, 0xb5, 0x6e, 0x88, + 0x53, 0x79, 0xf3, 0xc3, 0xab, 0x1b, 0xf7, 0x56, 0xef, 0x6d, 0x00, 0x64, 0x3f, 0x0a, 0x37, 0x52, + 0xe8, 0x23, 0xbd, 0xf6, 0x31, 0xf1, 0x18, 0x4d, 0xe8, 0x7b, 0x76, 0x2c, 0x47, 0x51, 0x2a, 0x3b, + 0xb5, 0xd3, 0xb5, 0x4f, 0xcf, 0xb5, 0x57, 0x44, 0x0b, 0x26, 0xf1, 0xbd, 0x4e, 0x1d, 0x7e, 0xb6, + 0xac, 0xff, 0x5e, 0x17, 0x4f, 0xcd, 0x80, 0x74, 0x2d, 0xf4, 0x0e, 0x0c, 0xa7, 0xdd, 0x15, 0xed, + 0x84, 0x87, 0xd9, 0x81, 0x0c, 0x07, 0xe9, 0xd0, 0x4e, 0xa4, 0xdb, 0x69, 0xd0, 0xb7, 0x27, 0xc4, + 0x8a, 0xfe, 0x26, 0xe3, 0x38, 0x8a, 0x3b, 0x4d, 0x6a, 0x3e, 0x24, 0xe6, 0x43, 0x27, 0x4d, 0x77, + 0xc7, 0xb2, 0xd3, 0xa2, 0x86, 0xb6, 0x10, 0x9b, 0xbb, 0x29, 0xd0, 0x26, 0x96, 0xee, 0x76, 0x67, + 0xae, 0xd8, 0x96, 0x00, 0x7a, 0x9d, 0x79, 0x6a, 0xeb, 0x88, 0xc3, 0x79, 0x1b, 0x74, 0x0e, 0x9c, + 0xdd, 0xce, 0x42, 0xf1, 0x0b, 0x42, 0x50, 0x5f, 0x16, 0x35, 0x7e, 0xa9, 0x3f, 0x92, 0x76, 0x1a, + 0xd9, 0x6e, 0x14, 0x86, 0xd2, 0x4d, 0xed, 0x51, 0xd2, 0x11, 0x44, 0x83, 0xaf, 0x09, 0x2b, 0x27, + 0xc1, 0x7d, 0x39, 0xf0, 0x61, 0xc1, 0xf1, 0xda, 0x24, 0x1d, 0x3e, 0x20, 0x4e, 0xbc, 0xe7, 0xa7, + 0xc3, 0xf5, 0xdb, 0x08, 0x9b, 0x58, 0xe2, 0x46, 0x81, 0x0d, 0x5c, 0xc5, 0xe5, 0x10, 0x29, 0x56, + 0xda, 0x8f, 0x89, 0x39, 0xe6, 0x19, 0xad, 0x77, 0x19, 0xe7, 0x62, 0xfe, 0xdb, 0x7e, 0x98, 0xa4, + 0x4e, 0xe8, 0x4a, 0x1b, 0xe8, 0x84, 0x8b, 0x6e, 0x5a, 0x7f, 0x5d, 0x33, 0xe9, 0xcd, 0x13, 0xe0, + 0x54, 0xeb, 0xd1, 0x68, 0x1c, 0xc8, 0x54, 0xb6, 0x0f, 0x8b, 0x05, 0xa2, 0x37, 0x0e, 0x61, 0x4a, + 0x03, 0x9d, 0x06, 0xce, 0x88, 0x60, 0xd4, 0xa9, 0x01, 0xe6, 0x93, 0x00, 0x17, 0x58, 0xd1, 0xa0, + 0xf9, 0x4f, 0x89, 0x63, 0xd2, 0x99, 0x10, 0xc9, 0x99, 0xca, 0xb1, 0x4c, 0xc6, 0x51, 0x98, 0x48, + 0x9a, 0x73, 0xa5, 0x7d, 0x42, 0x1c, 0xb9, 0x7a, 0xed, 0xde, 0xfd, 0x6b, 0xeb, 0x6b, 0x0f, 0xae, + 0x5d, 0x55, 0xe2, 0x45, 0x24, 0x5f, 0x46, 0xf2, 0xf2, 0x6f, 0xdb, 0x8d, 0x5d, 0x22, 0xf9, 0x4a, + 0xfb, 0xb8, 0x38, 0xa4, 0xda, 0x12, 0xf9, 0xe1, 0x04, 0x64, 0x53, 0x12, 0xdd, 0x57, 0x50, 0x14, + 0xa2, 0x9d, 0x50, 0xc6, 0x76, 0x86, 0x20, 0x52, 0x7d, 0xce, 0xfa, 0x1f, 0x42, 0x1c, 0xca, 0xd7, + 0x74, 0x2b, 0x1a, 0x44, 0xe1, 0x1e, 0xd4, 0x7a, 0x5a, 0x1c, 0x8f, 0x36, 0xfb, 0x93, 0x24, 0x9d, + 0xb8, 0x0e, 0x8a, 0xfc, 0x38, 0xf6, 0xb7, 0xe1, 0x0f, 0xdb, 0x1f, 0xd3, 0xf2, 0x56, 0x70, 0xbd, + 0xae, 0x0c, 0x02, 0x84, 0xdf, 0xd0, 0x08, 0x05, 0x4e, 0x92, 0x66, 0xcb, 0x53, 0xc4, 0xa4, 0x85, + 0x2b, 0x42, 0x8f, 0x1d, 0x77, 0x0b, 0xd4, 0x2a, 0x9b, 0xaa, 0xa5, 0x07, 0xaa, 0xef, 0x81, 0x13, + 0x0e, 0x26, 0xd0, 0x81, 0x96, 0xb8, 0x88, 0x2b, 0x51, 0x1f, 0xa2, 0xc4, 0x26, 0x09, 0xe4, 0x15, + 0xbe, 0x28, 0x3a, 0xc9, 0x30, 0x9a, 0x04, 0x24, 0xeb, 0x72, 0xb4, 0x09, 0x6b, 0x1d, 0x3b, 0x49, + 0xb2, 0x13, 0xc5, 0xbc, 0xd6, 0x85, 0x37, 0x5b, 0x7d, 0x27, 0x48, 0x64, 0xfb, 0xa8, 0x58, 0xde, + 0xf1, 0xc3, 0x7c, 0xbe, 0x45, 0x02, 0x7b, 0x5a, 0x74, 0xc6, 0x7e, 0x38, 0x00, 0xc9, 0xb2, 0xfb, + 0x71, 0x34, 0xb2, 0x69, 0x19, 0x09, 0x28, 0xad, 0x3b, 0x24, 0x51, 0x5b, 0x69, 0x1f, 0x11, 0x8b, + 0xe3, 0xc9, 0x66, 0xe0, 0xbb, 0xb8, 0xdc, 0xa3, 0xba, 0xe9, 0x43, 0xc0, 0x22, 0x90, 0xdb, 0x32, + 0xe8, 0x3c, 0x41, 0x4d, 0x00, 0x47, 0xa1, 0x97, 0x4c, 0xc6, 0x63, 0xf8, 0xcb, 0xcb, 0x49, 0x7e, + 0x8c, 0x44, 0x00, 0xf8, 0x36, 0x72, 0xdc, 0x21, 0xa2, 0x00, 0x6d, 0xa7, 0x88, 0x97, 0x1d, 0xb1, + 0x12, 0x38, 0x93, 0xd0, 0x1d, 0x02, 0xd6, 0xb4, 0xa6, 0xa7, 0x11, 0xd8, 0x9b, 0xb5, 0xb3, 0xd0, + 0x7b, 0x7e, 0xe2, 0xdb, 0xa3, 0xc8, 0x93, 0x9d, 0xd3, 0xba, 0x0d, 0x15, 0x16, 0x61, 0xae, 0xda, + 0x24, 0x3a, 0x4a, 0x2a, 0x5e, 0x22, 0x48, 0xa0, 0xb0, 0x72, 0xe4, 0xf8, 0x81, 0xed, 0x78, 0x1e, + 0xc8, 0x52, 0xd2, 0x79, 0x59, 0x2f, 0x2f, 0x46, 0x25, 0x7a, 0x1d, 0xc6, 0xb8, 0x6e, 0x34, 0x09, + 0x51, 0x6a, 0xc0, 0x1a, 0x21, 0x01, 0xce, 0x40, 0x8f, 0x79, 0x24, 0x8b, 0xfe, 0x12, 0x82, 0xc8, + 0x76, 0x56, 0x69, 0x1c, 0x88, 0x74, 0x46, 0xc5, 0xd7, 0xa9, 0x05, 0x24, 0x92, 0x44, 0x9a, 0x0d, + 0x24, 0x28, 0xe5, 0x96, 0x0c, 0x3b, 0xe7, 0xe9, 0x13, 0x90, 0x23, 0x88, 0x06, 0x7e, 0x68, 0x6f, + 0xc9, 0xdd, 0xce, 0x5b, 0xd4, 0x74, 0x46, 0x3c, 0xb5, 0xe3, 0x24, 0xa8, 0xb7, 0xd0, 0x19, 0x45, + 0xc6, 0x93, 0x63, 0x50, 0x70, 0x92, 0x9e, 0x51, 0x32, 0xe8, 0x5c, 0x37, 0x39, 0xf3, 0xbc, 0x38, + 0xe9, 0x84, 0x20, 0x24, 0x93, 0x04, 0x01, 0x3b, 0xf1, 0x00, 0xe4, 0xb8, 0x80, 0xd3, 0x3d, 0x82, + 0x09, 0xa2, 0x03, 0x2b, 0x8b, 0x82, 0x6d, 0x80, 0x41, 0x5d, 0x33, 0x02, 0x7f, 0x91, 0x08, 0x0c, + 0xe4, 0x91, 0xd0, 0x61, 0x12, 0xa4, 0x64, 0x65, 0xe2, 0xdd, 0xbe, 0x1f, 0xc8, 0xce, 0x7d, 0xb2, + 0x25, 0x68, 0x12, 0x87, 0x8e, 0xd9, 0xbe, 0x41, 0x64, 0x03, 0xd4, 0x89, 0x96, 0x2e, 0x12, 0xfa, + 0x81, 0x5e, 0x7a, 0x94, 0x8e, 0x99, 0x1d, 0x0f, 0x69, 0x30, 0x74, 0xc2, 0x96, 0x6d, 0x27, 0x98, + 0xc8, 0xce, 0xbb, 0x99, 0x5e, 0x41, 0x93, 0xef, 0x01, 0x40, 0xbf, 0xef, 0xcb, 0xb8, 0xf3, 0x1e, + 0x0d, 0x3e, 0x29, 0x9e, 0x50, 0x2c, 0x52, 0xfa, 0x18, 0xa3, 0x3e, 0x26, 0x69, 0xe7, 0x4b, 0xb8, + 0x60, 0x94, 0xee, 0x24, 0x0a, 0x77, 0xed, 0x71, 0x12, 0x6a, 0xf6, 0x7d, 0x99, 0xf0, 0x78, 0x52, + 0x3c, 0x9e, 0x7d, 0x40, 0x0a, 0xfb, 0x6c, 0x80, 0xfe, 0x2b, 0x01, 0xbd, 0x28, 0x5e, 0x24, 0xa6, + 0x49, 0x3b, 0x94, 0x3b, 0xd4, 0x25, 0xf0, 0xc3, 0x2d, 0xdc, 0x7a, 0x14, 0x91, 0xfc, 0x3e, 0x7c, + 0x91, 0x60, 0xfa, 0x3b, 0x5f, 0x31, 0xe9, 0x8a, 0x46, 0x5c, 0x03, 0x25, 0x3a, 0xbe, 0x4f, 0xe0, + 0x80, 0x4e, 0x26, 0x27, 0x71, 0xff, 0x82, 0xa9, 0xbe, 0x4a, 0x4b, 0x7d, 0x49, 0x3c, 0x43, 0xf8, + 0x83, 0xe6, 0xc5, 0xc0, 0xb4, 0x88, 0x8c, 0xb5, 0x52, 0x2b, 0x17, 0xec, 0xdd, 0x04, 0xcc, 0x6c, + 0xc7, 0xa6, 0xb5, 0x80, 0xe0, 0x68, 0x79, 0x26, 0xe0, 0x1f, 0x10, 0x70, 0x30, 0x15, 0x66, 0x2b, + 0x31, 0xca, 0x1d, 0x46, 0x40, 0xf8, 0x8e, 0x43, 0x1d, 0xc0, 0xca, 0x10, 0xd2, 0xf1, 0xae, 0x1d, + 0xc1, 0xf4, 0x31, 0x90, 0xb0, 0xb3, 0x49, 0x5f, 0x00, 0xa0, 0x9f, 0x28, 0xa6, 0x6e, 0x46, 0x1f, + 0x75, 0x5c, 0x9a, 0xa6, 0xda, 0x32, 0x7b, 0x68, 0x99, 0xc9, 0xec, 0xed, 0x44, 0x76, 0xdf, 0x71, + 0xd3, 0x28, 0x66, 0x1e, 0x4a, 0x02, 0xf5, 0x9c, 0x78, 0x0a, 0xd5, 0x30, 0x8a, 0x53, 0xd8, 0x57, + 0x90, 0x70, 0x81, 0x3f, 0xf2, 0xd3, 0xdc, 0xc8, 0xf6, 0x11, 0xb4, 0xf5, 0x9d, 0x96, 0x38, 0x5e, + 0x32, 0x82, 0xf7, 0x55, 0x0f, 0xd4, 0x3f, 0x25, 0x4c, 0x64, 0x03, 0x5b, 0x6f, 0xd6, 0x56, 0x51, + 0x4e, 0xa3, 0x09, 0xd8, 0x9f, 0xbe, 0x4d, 0xf4, 0x1b, 0xe2, 0xd6, 0xbe, 0x09, 0x7c, 0xc1, 0x7d, + 0x33, 0x0a, 0xbd, 0x44, 0xed, 0xab, 0xcf, 0x88, 0x13, 0xa0, 0x0b, 0x33, 0xba, 0x34, 0xb4, 0x44, + 0xe5, 0x36, 0x85, 0x0d, 0x23, 0x48, 0x80, 0xd6, 0x54, 0xad, 0x62, 0xf0, 0x8b, 0xac, 0xe2, 0x3c, + 0x72, 0x52, 0xf3, 0xba, 0x1f, 0x38, 0x83, 0x44, 0x99, 0x7d, 0xc3, 0xec, 0xb2, 0x31, 0x04, 0x12, + 0xb2, 0x15, 0xf0, 0x22, 0xf8, 0x2f, 0x24, 0x03, 0xb8, 0x48, 0x72, 0x60, 0x0a, 0x25, 0x99, 0x3e, + 0x34, 0x3e, 0x87, 0xb5, 0xbe, 0xc8, 0x8f, 0x52, 0x89, 0xae, 0x03, 0xef, 0xae, 0xed, 0x17, 0xc4, + 0xa9, 0x1d, 0xb9, 0xe9, 0x8c, 0x7d, 0x32, 0x34, 0x28, 0xe2, 0xa8, 0xb9, 0xac, 0x74, 0xa0, 0xa8, + 0xb0, 0xbb, 0x2c, 0x69, 0x8d, 0x54, 0xf3, 0xdb, 0x64, 0x44, 0xd3, 0x21, 0xc0, 0x1b, 0x46, 0x81, + 0xd7, 0x59, 0x26, 0x74, 0x40, 0x95, 0x60, 0x0c, 0x7c, 0x73, 0x93, 0xce, 0x0a, 0x71, 0x13, 0x8c, + 0xe0, 0xb6, 0x13, 0xfa, 0xe9, 0xae, 0x3d, 0x89, 0x83, 0xce, 0x63, 0x5a, 0x64, 0x2a, 0x4d, 0x27, + 0xac, 0xea, 0x28, 0x29, 0x36, 0xb0, 0xd9, 0x1f, 0xdb, 0x5a, 0x6a, 0x88, 0xcd, 0x4f, 0x68, 0x9b, + 0x34, 0x76, 0x62, 0x18, 0xe9, 0xa0, 0xcd, 0x4e, 0x53, 0xc0, 0x21, 0x21, 0x6b, 0xbb, 0xdc, 0xb6, + 0x44, 0xb7, 0xfc, 0xc9, 0x4e, 0xfc, 0x01, 0x78, 0x2f, 0x93, 0x58, 0x76, 0x8e, 0x53, 0x1f, 0x58, + 0x26, 0xd3, 0x94, 0xac, 0x57, 0x1f, 0xe8, 0x06, 0xdf, 0x12, 0xf4, 0x37, 0x46, 0xfe, 0x00, 0xc5, + 0xa6, 0xd3, 0x21, 0x72, 0x80, 0x34, 0x71, 0x3f, 0xcf, 0x4f, 0x94, 0x27, 0x52, 0xe8, 0x75, 0x82, + 0x7a, 0x3d, 0x2b, 0x9e, 0x8c, 0x06, 0x89, 0xed, 0x39, 0xa9, 0x03, 0x82, 0x86, 0xb2, 0x47, 0x1c, + 0xb4, 0x61, 0xd3, 0xf1, 0xa2, 0x9d, 0x4e, 0x57, 0xfb, 0x34, 0x15, 0xd2, 0xfc, 0x24, 0xf9, 0x19, + 0x3d, 0xf1, 0x8a, 0xe9, 0xd3, 0x90, 0xdd, 0x78, 0x4f, 0x6e, 0xae, 0xdd, 0xbb, 0xb9, 0x66, 0x70, + 0xe1, 0x21, 0x30, 0xe1, 0x0e, 0xf2, 0xc0, 0x8a, 0xc5, 0xf9, 0x47, 0xe9, 0xbf, 0xa7, 0x68, 0x1f, + 0x90, 0xe3, 0x56, 0x5b, 0x1c, 0x2e, 0x68, 0xcc, 0xdd, 0x7e, 0xdf, 0x7a, 0xc9, 0xf4, 0x77, 0xa1, + 0x6d, 0x20, 0x3d, 0x68, 0xae, 0x9a, 0xc6, 0x7a, 0xd3, 0x1c, 0xbe, 0x7e, 0xfb, 0x16, 0xb8, 0x6d, + 0x28, 0xb3, 0xee, 0x48, 0x6f, 0x5b, 0x32, 0x81, 0xce, 0x0d, 0x16, 0x1d, 0x68, 0x25, 0x0d, 0x06, + 0xb5, 0x82, 0x16, 0x6b, 0x24, 0x9e, 0xcc, 0xc7, 0x82, 0xcb, 0xbb, 0xce, 0x9c, 0x80, 0x9d, 0xec, + 0x66, 0xd8, 0x8f, 0x32, 0x21, 0x47, 0x61, 0xf4, 0xd0, 0xe2, 0xb2, 0x27, 0x06, 0xd0, 0xb3, 0xe6, + 0x04, 0xfc, 0xa5, 0xcc, 0x1d, 0x53, 0x66, 0xaf, 0xa1, 0x37, 0x74, 0xd7, 0x09, 0x3d, 0xdf, 0x43, + 0x76, 0xa2, 0x3e, 0x2e, 0x5b, 0x5f, 0x17, 0x4f, 0xcf, 0x98, 0xee, 0x3a, 0x08, 0xca, 0xc7, 0x9f, + 0x12, 0x77, 0xab, 0xf1, 0xea, 0xd8, 0x9e, 0x76, 0xb3, 0x57, 0xac, 0x73, 0xe6, 0xdc, 0x37, 0xc0, + 0xdb, 0x1c, 0x8f, 0xef, 0xa2, 0x17, 0x97, 0x0c, 0xfd, 0x31, 0xfb, 0x9f, 0x06, 0x38, 0x72, 0xd1, + 0xac, 0xf7, 0xc5, 0x8b, 0xfb, 0x0c, 0x99, 0xc5, 0xff, 0x15, 0xe4, 0x7f, 0x0e, 0xae, 0x5e, 0xe5, + 0x1f, 0x5b, 0x2f, 0x8a, 0x63, 0x39, 0x78, 0x15, 0x6c, 0x3c, 0x40, 0x17, 0x00, 0x83, 0x0a, 0xf6, + 0x05, 0x6a, 0x24, 0xc4, 0xb7, 0x4d, 0x2e, 0xdd, 0x00, 0x1b, 0xa8, 0xe8, 0x46, 0x9d, 0x13, 0xb0, + 0x18, 0xed, 0x91, 0xf3, 0x11, 0x7b, 0x0f, 0xa4, 0x43, 0x5b, 0x52, 0x8e, 0x15, 0x1a, 0xf5, 0x73, + 0x67, 0x69, 0x5e, 0xfa, 0x46, 0x4c, 0x5f, 0xb6, 0x7e, 0x50, 0x63, 0x89, 0xb9, 0xb1, 0xb1, 0x41, + 0x46, 0xf1, 0x01, 0xec, 0xca, 0x64, 0x0d, 0x09, 0x59, 0xb6, 0x94, 0x8a, 0x04, 0x88, 0x09, 0x1b, + 0xc7, 0xba, 0xf6, 0x24, 0xd9, 0x07, 0x1f, 0x67, 0x3e, 0x51, 0xc6, 0x6c, 0xfa, 0x80, 0xc2, 0xa5, + 0x8c, 0x2f, 0x48, 0x1b, 0x35, 0x79, 0x7e, 0x4c, 0x16, 0x97, 0x36, 0x23, 0x6a, 0xd1, 0xde, 0x22, + 0x3b, 0xa1, 0x1a, 0x26, 0xe8, 0x1a, 0x58, 0x22, 0x02, 0x40, 0x86, 0xd7, 0x7a, 0x41, 0x1c, 0x51, + 0x68, 0x82, 0x93, 0x3f, 0x49, 0xee, 0xcb, 0x71, 0xb0, 0x8b, 0x13, 0xe1, 0x86, 0x26, 0x5d, 0x34, + 0x39, 0x35, 0xda, 0x72, 0xbe, 0xa1, 0x97, 0x73, 0x0f, 0xe2, 0x1c, 0x19, 0x93, 0x02, 0xbc, 0x24, + 0xe6, 0xc7, 0xf4, 0x8b, 0x65, 0x7f, 0x69, 0xb5, 0xd3, 0x2b, 0xf7, 0xe9, 0xf1, 0x9f, 0xdd, 0xb7, + 0xc4, 0x1c, 0xff, 0x35, 0x15, 0x73, 0x34, 0x8b, 0x7b, 0x4a, 0x5d, 0x53, 0x84, 0x79, 0xc3, 0x4c, + 0xbc, 0xa1, 0x91, 0x44, 0x9b, 0x80, 0x70, 0xc0, 0x28, 0x56, 0x04, 0x2f, 0xfb, 0x03, 0x7a, 0x99, + 0xa5, 0xe1, 0xc6, 0xc6, 0xd5, 0xcc, 0x20, 0xde, 0x89, 0x40, 0x5e, 0x2a, 0x42, 0x21, 0xeb, 0xdf, + 0xea, 0xe2, 0x89, 0xa2, 0x44, 0x24, 0xb4, 0x04, 0xaf, 0x7d, 0x89, 0x49, 0x9c, 0xd8, 0xb4, 0x7a, + 0x4f, 0x2d, 0xfe, 0x99, 0x5e, 0x65, 0xef, 0x1e, 0xfe, 0xad, 0x06, 0x4e, 0x87, 0x02, 0x84, 0x65, + 0xf7, 0xdb, 0x75, 0x21, 0x8c, 0x6e, 0x8f, 0x8b, 0xa5, 0x4c, 0x0f, 0x07, 0x89, 0xa2, 0xd2, 0x54, + 0x64, 0xf6, 0x28, 0x62, 0x52, 0x60, 0x68, 0x8b, 0x36, 0xb4, 0x8c, 0x32, 0x73, 0xb4, 0xa5, 0x68, + 0x68, 0xb0, 0xa1, 0xc6, 0x0e, 0xd8, 0xf8, 0x7e, 0x44, 0x02, 0x42, 0xe1, 0x0b, 0x4b, 0x18, 0x6e, + 0x0f, 0x9b, 0x41, 0xb4, 0x49, 0x7b, 0x33, 0x45, 0x73, 0x10, 0x74, 0xb9, 0x30, 0x2d, 0xa2, 0xb4, + 0x48, 0xd3, 0x90, 0x13, 0x19, 0xe3, 0x0e, 0x08, 0x9b, 0x16, 0x7c, 0xdd, 0x06, 0x1f, 0x29, 0xc6, + 0xcf, 0x1c, 0x90, 0xc0, 0x10, 0x02, 0xc5, 0xc2, 0xbe, 0xa4, 0x05, 0x98, 0xe3, 0x3c, 0x5f, 0xed, + 0xbd, 0xd6, 0x65, 0xb1, 0xc2, 0x3c, 0x02, 0x4b, 0x00, 0x20, 0xaa, 0xa2, 0xd4, 0xe9, 0xe0, 0x90, + 0x48, 0x62, 0xdd, 0x14, 0x42, 0xb1, 0x57, 0x86, 0xbb, 0x15, 0xe3, 0xd0, 0xcb, 0x00, 0xc7, 0x77, + 0x17, 0xb6, 0x39, 0x07, 0x1c, 0x4c, 0xe5, 0xf6, 0x00, 0xb9, 0xa9, 0x11, 0x50, 0x07, 0xbc, 0x89, + 0x88, 0x8b, 0xd6, 0x79, 0x0d, 0xea, 0x0b, 0x60, 0x4d, 0x0e, 0x0a, 0xca, 0xfa, 0x9d, 0x9a, 0x68, + 0xe7, 0x52, 0x80, 0xbb, 0x19, 0x29, 0x0a, 0xcc, 0xa0, 0x0c, 0x47, 0x20, 0xfb, 0xca, 0x78, 0xa1, + 0x17, 0x43, 0x91, 0xa6, 0x72, 0xb4, 0x31, 0x00, 0x56, 0x42, 0x0b, 0xdb, 0x76, 0xf9, 0x0b, 0xc7, + 0x78, 0xec, 0x5f, 0x29, 0x36, 0x9f, 0x16, 0xf3, 0x6c, 0xe9, 0x12, 0x60, 0x32, 0x0a, 0xe0, 0x21, + 0x12, 0xc0, 0x3c, 0x97, 0x80, 0x22, 0xc3, 0xe6, 0x26, 0x01, 0x9e, 0x37, 0x78, 0x4a, 0x95, 0x13, + 0xca, 0xc3, 0x6d, 0x72, 0xc8, 0xac, 0x77, 0x4d, 0x59, 0xd7, 0x78, 0xaf, 0xc1, 0xca, 0x8b, 0x41, + 0x3b, 0x6f, 0x71, 0x06, 0xdc, 0xfa, 0x4c, 0xb8, 0x84, 0xa4, 0xf5, 0x2f, 0x35, 0x13, 0xf0, 0xf5, + 0x18, 0xfe, 0xf5, 0x12, 0xbd, 0x7b, 0x6e, 0xfa, 0xa1, 0x8b, 0x4e, 0x3a, 0xfa, 0x3a, 0x6c, 0x66, + 0xda, 0x3d, 0x31, 0xdf, 0xe7, 0x4e, 0x04, 0x7a, 0x69, 0xf5, 0x64, 0xaf, 0x72, 0x78, 0x8f, 0xff, + 0xa6, 0x99, 0xc1, 0x2c, 0xf3, 0x18, 0xf6, 0xb4, 0x14, 0x79, 0xc0, 0x2d, 0x05, 0xef, 0xda, 0xdf, + 0x96, 0xc5, 0x8f, 0x59, 0x96, 0x42, 0x4d, 0xa3, 0x1c, 0xec, 0xa1, 0xcf, 0x59, 0x8a, 0x85, 0xee, + 0x65, 0x31, 0xa7, 0x60, 0xc3, 0xd2, 0x27, 0x01, 0x77, 0xcb, 0xd8, 0x0e, 0x50, 0x25, 0x37, 0x61, + 0xc2, 0x07, 0x37, 0x55, 0xdc, 0xa7, 0x98, 0x6f, 0xd6, 0x9f, 0xd5, 0xcd, 0x3d, 0x44, 0x61, 0x7b, + 0x23, 0x8e, 0x26, 0x63, 0x5e, 0x32, 0x48, 0xd1, 0x26, 0xe6, 0xb5, 0xb6, 0xb3, 0xe5, 0x96, 0x89, + 0x50, 0xa7, 0xd6, 0xff, 0x22, 0x96, 0x79, 0x0e, 0x1e, 0x0b, 0x0b, 0x42, 0x4a, 0x7c, 0xba, 0xb7, + 0x07, 0x6c, 0x45, 0x0f, 0x6a, 0x68, 0xbf, 0x23, 0x96, 0x38, 0xf2, 0x41, 0xdc, 0xb4, 0x74, 0xbc, + 0x7e, 0xd0, 0xe1, 0xc9, 0xed, 0x6c, 0x6c, 0xf7, 0x82, 0x58, 0x32, 0x01, 0xc3, 0x02, 0x42, 0xfa, + 0xeb, 0xe6, 0x55, 0x76, 0x8d, 0xd8, 0x65, 0x88, 0xa9, 0xed, 0x0e, 0xc6, 0x52, 0xb8, 0x80, 0xc5, + 0xee, 0x67, 0xc5, 0xb1, 0x6a, 0x80, 0x68, 0x88, 0x26, 0xc1, 0x06, 0xaa, 0x92, 0x02, 0x31, 0x57, + 0x00, 0xca, 0x5a, 0xf4, 0x93, 0x42, 0xde, 0x8a, 0xf7, 0x8d, 0x3b, 0x20, 0x84, 0x18, 0x97, 0x11, + 0x21, 0x41, 0x00, 0x8b, 0x74, 0x04, 0x05, 0x9b, 0x26, 0xe3, 0xdb, 0x62, 0x31, 0x54, 0xa3, 0x34, + 0x0d, 0x5f, 0xe9, 0xed, 0x05, 0xb7, 0x57, 0x6c, 0xea, 0xbe, 0x2e, 0x1e, 0x2b, 0xb6, 0xe0, 0xc4, + 0xda, 0xc3, 0xcf, 0x91, 0x57, 0x1f, 0x95, 0xe1, 0xf8, 0x9c, 0x29, 0x03, 0x1b, 0x32, 0x7d, 0x14, + 0x08, 0x44, 0x3d, 0xeb, 0xa2, 0x78, 0x76, 0x0f, 0x08, 0x99, 0x37, 0x74, 0xa8, 0xe4, 0x0d, 0x59, + 0x7f, 0xdf, 0x30, 0x75, 0xed, 0x16, 0xec, 0x6a, 0xd0, 0x8d, 0xe8, 0x55, 0xe5, 0x38, 0x9f, 0x15, + 0x0b, 0x01, 0x77, 0xd1, 0xaa, 0x76, 0xaa, 0x57, 0x39, 0xba, 0xa7, 0xfe, 0xee, 0xfe, 0x7b, 0x5d, + 0xcc, 0xab, 0xbf, 0xc9, 0xfa, 0xab, 0x34, 0x98, 0xf6, 0xe4, 0x50, 0x16, 0x28, 0x6e, 0xe0, 0x90, + 0x9f, 0x6d, 0xf2, 0x3c, 0xaa, 0x1a, 0xb5, 0x86, 0xb0, 0xb3, 0xd8, 0x6a, 0xc7, 0x20, 0x52, 0x51, + 0x06, 0x07, 0x76, 0x8a, 0x89, 0x8e, 0x72, 0x55, 0xaa, 0x36, 0x6b, 0x4d, 0xd0, 0x8b, 0xf7, 0x54, + 0xbe, 0x16, 0x4c, 0xfe, 0xd8, 0xd9, 0x45, 0xfe, 0xda, 0x23, 0x99, 0x0e, 0x23, 0x4f, 0x45, 0x92, + 0x99, 0xef, 0x34, 0xaf, 0x77, 0xa0, 0xf1, 0x04, 0xe2, 0x76, 0x07, 0xa2, 0xb7, 0x42, 0xdc, 0xb5, + 0xa0, 0x9d, 0x23, 0xb5, 0x68, 0xde, 0x7e, 0x17, 0x75, 0x4e, 0x24, 0xc5, 0x80, 0x1e, 0x62, 0x71, + 0xd5, 0x5b, 0xe8, 0x5c, 0x32, 0x40, 0x0a, 0x61, 0x8d, 0xe1, 0x04, 0x25, 0x98, 0xb6, 0xac, 0xd6, + 0xf4, 0x96, 0x85, 0x00, 0x7c, 0x88, 0x0d, 0x7d, 0x08, 0xd9, 0xc6, 0x32, 0xf6, 0x01, 0xb9, 0x15, + 0x6d, 0x66, 0x74, 0x3b, 0xd1, 0x60, 0x02, 0x3f, 0x28, 0x76, 0xa4, 0x21, 0x10, 0xe4, 0xc9, 0x9d, + 0x7c, 0xc8, 0x21, 0x3d, 0x44, 0xb7, 0xe7, 0x43, 0x0e, 0x13, 0x7f, 0xff, 0x5b, 0x81, 0xbd, 0x57, + 0xc0, 0xb1, 0x4c, 0x37, 0xdc, 0x28, 0x96, 0x65, 0x97, 0x1a, 0x61, 0x07, 0xd2, 0x81, 0xad, 0x77, + 0x33, 0xc2, 0x64, 0x48, 0x96, 0x37, 0x07, 0x5a, 0x25, 0x38, 0x40, 0xc5, 0xf2, 0x20, 0x40, 0x9e, + 0x4c, 0x21, 0x26, 0x48, 0x38, 0x72, 0x40, 0xe3, 0x36, 0x19, 0x07, 0x91, 0x03, 0xee, 0x29, 0x76, + 0xd3, 0x84, 0x26, 0x06, 0x58, 0xbf, 0x5e, 0x13, 0x27, 0x2b, 0xa7, 0xdf, 0x33, 0x3c, 0x83, 0x10, + 0xd9, 0x44, 0x45, 0x2a, 0x86, 0xa0, 0x25, 0xae, 0x67, 0xf9, 0x7a, 0x9a, 0x8c, 0x29, 0xcd, 0x41, + 0xc6, 0x42, 0xfb, 0x29, 0x71, 0x74, 0x00, 0xbe, 0x06, 0x50, 0x21, 0x76, 0xc2, 0x2d, 0x90, 0x1b, + 0xb9, 0xed, 0x47, 0x93, 0x44, 0x89, 0x08, 0x3a, 0x2b, 0xc6, 0x57, 0x20, 0x97, 0x42, 0xf2, 0x76, + 0x21, 0xa2, 0x23, 0x1c, 0x1f, 0xde, 0x58, 0x3f, 0x30, 0x81, 0xa0, 0xdf, 0x64, 0xe0, 0xea, 0x50, + 0x67, 0x0e, 0xc2, 0x99, 0x27, 0x2b, 0xc0, 0xed, 0xb5, 0x60, 0xeb, 0x87, 0xb5, 0xd2, 0x98, 0xeb, + 0x10, 0x45, 0xdf, 0x8d, 0xd7, 0x49, 0x27, 0x6e, 0x5d, 0x99, 0x42, 0xa5, 0x44, 0xa0, 0x04, 0xa3, + 0x6f, 0x45, 0x77, 0xc6, 0xe9, 0xb4, 0xe8, 0x98, 0x1d, 0x20, 0x92, 0x47, 0xaf, 0x93, 0xc5, 0x97, + 0xf9, 0x08, 0x6c, 0x53, 0x59, 0x36, 0x4c, 0xa7, 0x45, 0xa9, 0xdd, 0x07, 0xfa, 0x72, 0xda, 0x7a, + 0x81, 0xbc, 0x0c, 0x63, 0x38, 0x99, 0x19, 0x0a, 0x14, 0xac, 0xbf, 0xad, 0x99, 0x76, 0x66, 0x0a, + 0xd3, 0x3d, 0xd9, 0x3a, 0x8b, 0x80, 0x7b, 0xb0, 0x9b, 0x71, 0xb5, 0x66, 0x2f, 0xb7, 0xc9, 0xc0, + 0xcf, 0xb6, 0x9f, 0xdd, 0x63, 0xc5, 0x2d, 0xdd, 0xa9, 0x6a, 0x5d, 0x14, 0xea, 0x58, 0xbf, 0x56, + 0x13, 0x27, 0x0a, 0xeb, 0x82, 0xa0, 0xf2, 0xd6, 0x95, 0x6b, 0x80, 0x8a, 0x2f, 0x93, 0x12, 0xfd, + 0x5b, 0x33, 0x57, 0x02, 0x3b, 0x4a, 0x4c, 0xaa, 0x9f, 0xe0, 0x19, 0x57, 0x9e, 0xfd, 0xe2, 0x46, + 0xa9, 0xe8, 0x3b, 0xcd, 0x1e, 0x4e, 0xa2, 0x70, 0xea, 0xb4, 0xa5, 0xcd, 0x85, 0xb2, 0xf8, 0x98, + 0xfd, 0x6a, 0x80, 0x58, 0xfd, 0xbc, 0x26, 0x9e, 0x99, 0x89, 0xe1, 0xc7, 0x53, 0xa7, 0xcb, 0x30, + 0x88, 0xe1, 0x54, 0x78, 0x0d, 0x33, 0x66, 0xea, 0xe1, 0xef, 0xdd, 0xae, 0x2b, 0x5a, 0xf4, 0x47, + 0x21, 0x3b, 0x80, 0x79, 0x14, 0xb5, 0x51, 0x01, 0x45, 0x0c, 0xa5, 0x3b, 0xa0, 0x49, 0xc9, 0x35, + 0xaa, 0x45, 0x1a, 0xf5, 0xf3, 0x82, 0x3f, 0xb8, 0xc6, 0xa9, 0x41, 0xca, 0x49, 0x80, 0x69, 0x06, + 0x43, 0x08, 0xae, 0xb4, 0xc3, 0xcc, 0xac, 0x91, 0xc1, 0x86, 0x7d, 0x26, 0xcf, 0xa0, 0xf1, 0xfe, + 0x48, 0xc9, 0x3b, 0xca, 0x6a, 0x51, 0xc6, 0xc7, 0xcb, 0xd2, 0xbb, 0x89, 0x22, 0xf8, 0x54, 0xce, + 0x91, 0xb7, 0x06, 0xc0, 0xbf, 0xef, 0xb8, 0x72, 0x33, 0x8a, 0xb6, 0xf4, 0x71, 0x52, 0x13, 0xfb, + 0x66, 0x8d, 0x34, 0x2d, 0x1f, 0xae, 0x3c, 0x2f, 0x4e, 0x1a, 0xd9, 0x64, 0xd0, 0x29, 0xbf, 0xbf, + 0x8b, 0x66, 0x46, 0x65, 0x88, 0x13, 0x32, 0xe2, 0x0b, 0xed, 0x33, 0xe2, 0x59, 0xa3, 0xdb, 0x54, + 0xfa, 0xd8, 0x56, 0xf9, 0xe3, 0x43, 0x24, 0x97, 0x3f, 0xad, 0x99, 0xe7, 0xa8, 0x10, 0xdc, 0xdc, + 0xe6, 0x5d, 0x8e, 0x83, 0xbe, 0xab, 0x20, 0x38, 0xed, 0x5b, 0xe2, 0x31, 0xbd, 0xf5, 0x15, 0x42, + 0xcb, 0xf3, 0xbd, 0xbd, 0x07, 0xf6, 0xaa, 0x1a, 0xbb, 0x77, 0xc5, 0xd1, 0xca, 0x59, 0xca, 0x26, + 0x08, 0x98, 0xd6, 0x07, 0x16, 0x62, 0x64, 0x51, 0xcf, 0x74, 0x02, 0xe3, 0x0f, 0x4c, 0x51, 0xef, + 0x48, 0xb9, 0xa5, 0x92, 0xbf, 0xd6, 0x6f, 0xd4, 0x44, 0x37, 0x47, 0xe4, 0x26, 0x78, 0x8e, 0xb0, + 0x6b, 0x4b, 0x4f, 0x71, 0x11, 0xed, 0xd0, 0xa6, 0xaf, 0x1c, 0xea, 0x3c, 0xc7, 0xaf, 0x3c, 0x34, + 0x30, 0xe8, 0xf8, 0x11, 0x78, 0x35, 0x9a, 0x50, 0x1a, 0x75, 0xd3, 0x81, 0xf0, 0xdb, 0x53, 0xae, + 0x5a, 0x57, 0xb4, 0x69, 0x68, 0xe4, 0x1a, 0xa7, 0x03, 0x6a, 0x2b, 0xb8, 0x20, 0x5e, 0xad, 0x00, + 0x6b, 0x3b, 0x41, 0x10, 0xed, 0xc0, 0xef, 0x34, 0x82, 0x68, 0x75, 0x1b, 0x3e, 0xd9, 0x3a, 0x70, + 0x20, 0xc3, 0x67, 0xdd, 0x35, 0xed, 0xb0, 0x4a, 0x32, 0xb2, 0x53, 0x4a, 0x44, 0x00, 0x4d, 0xd2, + 0xe2, 0x46, 0xc7, 0x9b, 0x5a, 0x69, 0xa5, 0x49, 0x15, 0x23, 0x12, 0x99, 0xb3, 0xfe, 0x7f, 0xcd, + 0x4c, 0x25, 0xad, 0xd3, 0x76, 0xc5, 0x49, 0x13, 0x94, 0xa2, 0x02, 0x30, 0x05, 0x02, 0x24, 0x8e, + 0xf3, 0x23, 0x76, 0xee, 0xdd, 0xa1, 0xf4, 0xc2, 0x6a, 0x40, 0x74, 0x23, 0x7b, 0x00, 0x1b, 0x7d, + 0x4c, 0x27, 0x4b, 0x99, 0xff, 0xb8, 0x80, 0xb0, 0x86, 0xfe, 0x60, 0x88, 0x47, 0x95, 0x11, 0xb8, + 0x24, 0xbb, 0xca, 0x8e, 0x03, 0x71, 0xb3, 0x29, 0x20, 0x18, 0xdb, 0xdc, 0x65, 0xd5, 0xa4, 0x98, + 0x05, 0x7c, 0x4e, 0xb2, 0x78, 0xf7, 0xb8, 0x03, 0xa3, 0x96, 0xd9, 0x11, 0x60, 0xb7, 0xe9, 0x26, + 0x56, 0x62, 0x65, 0xfd, 0x53, 0xd3, 0x5c, 0x9c, 0x02, 0x84, 0xab, 0x93, 0xec, 0xe2, 0xe3, 0x32, + 0x95, 0x36, 0x31, 0x94, 0xd7, 0xca, 0x81, 0x9a, 0xe9, 0x3d, 0x9a, 0xe3, 0x55, 0x68, 0xd1, 0xfd, + 0x5f, 0xcd, 0x2c, 0xb0, 0x02, 0x8b, 0x58, 0x0a, 0xab, 0xa6, 0x08, 0x58, 0xd7, 0xa9, 0x46, 0xce, + 0x64, 0x90, 0xf0, 0xda, 0x85, 0x34, 0xa4, 0xce, 0x4b, 0xa8, 0x33, 0x87, 0xec, 0x38, 0x02, 0x36, + 0x06, 0xb3, 0x9d, 0x92, 0x20, 0x2d, 0x1d, 0x11, 0x16, 0x59, 0x6e, 0x9e, 0x48, 0x80, 0x1d, 0x8f, + 0xc2, 0x00, 0xd5, 0x37, 0x3b, 0xf9, 0x55, 0x79, 0xee, 0x82, 0x6b, 0xb9, 0x19, 0xf8, 0x09, 0xda, + 0x1c, 0x33, 0x09, 0xbe, 0x30, 0x05, 0xdd, 0x60, 0x90, 0xd0, 0xf1, 0x89, 0x49, 0xf3, 0x43, 0xda, + 0xb6, 0x19, 0xe9, 0xb8, 0xa3, 0x7a, 0x55, 0xba, 0x02, 0x22, 0x89, 0xc0, 0x91, 0xe5, 0x1c, 0x3d, + 0x19, 0x5f, 0x67, 0x1b, 0xe4, 0x36, 0xb6, 0xc1, 0xb5, 0x1d, 0xd2, 0x69, 0xeb, 0x32, 0x36, 0x92, + 0x9e, 0x06, 0xd1, 0x20, 0xea, 0xf7, 0x3b, 0xaf, 0xea, 0x24, 0x4b, 0xd6, 0x18, 0x76, 0x7a, 0x59, + 0x96, 0x38, 0x70, 0x42, 0x36, 0xdc, 0xab, 0x85, 0x24, 0x11, 0xe1, 0x73, 0x89, 0xf0, 0x01, 0x41, + 0xc1, 0x26, 0x58, 0xd1, 0x1b, 0x3a, 0xcb, 0x52, 0xca, 0xfc, 0xbc, 0x45, 0xd3, 0x62, 0x86, 0x1b, + 0xa1, 0xa5, 0xce, 0xa0, 0xb3, 0xa6, 0xcf, 0x69, 0x8a, 0x56, 0xf4, 0x0a, 0x35, 0x97, 0x2c, 0xee, + 0x3a, 0xe5, 0x59, 0x2f, 0x4c, 0xc7, 0xc8, 0xf7, 0xe2, 0x08, 0x4f, 0x36, 0x69, 0x1b, 0x30, 0x08, + 0xc0, 0x32, 0xa2, 0xb2, 0x71, 0x7f, 0x57, 0xf0, 0x56, 0xa6, 0xc6, 0xed, 0xe7, 0xad, 0x94, 0x60, + 0xd6, 0x75, 0x0e, 0xa7, 0x10, 0xb0, 0x64, 0xe9, 0x33, 0xf8, 0x1d, 0xf0, 0x42, 0x9a, 0xfa, 0x9c, + 0xd8, 0x45, 0x9b, 0x95, 0x7b, 0x4f, 0x48, 0x66, 0x16, 0xa2, 0xdc, 0xf3, 0xa0, 0x03, 0x01, 0x15, + 0x73, 0x50, 0xeb, 0xbc, 0x3e, 0x96, 0x1d, 0xc2, 0x9e, 0x8d, 0xb2, 0xa5, 0xa2, 0x10, 0x8c, 0x01, + 0x27, 0xa3, 0x91, 0x13, 0x73, 0xc1, 0xc8, 0xa2, 0xf5, 0x9d, 0x9a, 0x38, 0x6a, 0x86, 0x7c, 0x28, + 0xb9, 0x14, 0xb8, 0xbd, 0x0a, 0x3d, 0xe9, 0x97, 0xce, 0xb0, 0x3e, 0xd5, 0xab, 0xea, 0xd7, 0xe3, + 0x3f, 0xbb, 0xd7, 0xc4, 0x1c, 0xff, 0x45, 0x29, 0x44, 0x75, 0x18, 0x87, 0x6e, 0x53, 0x4d, 0xaf, + 0x2c, 0xd7, 0x96, 0xba, 0x36, 0x06, 0xa6, 0xa2, 0x70, 0xd2, 0xe6, 0x87, 0x85, 0x9d, 0xea, 0xbe, + 0x36, 0x8c, 0x6a, 0x56, 0x58, 0x75, 0xd2, 0xbe, 0x82, 0x3e, 0x82, 0xc3, 0xa7, 0x49, 0x09, 0x73, + 0x09, 0xd1, 0x3b, 0xd3, 0xdb, 0x7b, 0x5c, 0x8f, 0xfe, 0x7d, 0x10, 0x6d, 0xa0, 0x45, 0x58, 0x13, + 0x4b, 0xc6, 0x4f, 0x44, 0x45, 0x9f, 0xa6, 0x41, 0xab, 0x42, 0x99, 0x32, 0x8a, 0x0e, 0x58, 0xfb, + 0xc1, 0x20, 0x96, 0x03, 0xa4, 0xb7, 0xe1, 0x1c, 0xaf, 0x58, 0x7f, 0x58, 0x33, 0xab, 0x41, 0x10, + 0x1a, 0x06, 0xb6, 0x4b, 0x34, 0x84, 0x1d, 0x11, 0x85, 0xd8, 0x93, 0xbd, 0x52, 0x37, 0xc2, 0xe4, + 0x2a, 0x75, 0xe9, 0x7e, 0x43, 0x88, 0xfc, 0x57, 0x35, 0x1e, 0xc0, 0xc4, 0x20, 0x50, 0x07, 0xe9, + 0x38, 0x75, 0x83, 0x72, 0x7a, 0x28, 0x3c, 0x51, 0x1f, 0x14, 0x64, 0x57, 0xc9, 0x8e, 0x71, 0xae, + 0x99, 0xe5, 0xe7, 0x3d, 0x39, 0x06, 0x9f, 0x5c, 0x79, 0x40, 0x2b, 0xc6, 0xee, 0xcb, 0x99, 0xb7, + 0x9f, 0xd4, 0x44, 0x27, 0xc7, 0xed, 0xf6, 0xed, 0x0d, 0xe5, 0x80, 0x47, 0x9b, 0x9b, 0xbb, 0x53, + 0x5b, 0x35, 0x4c, 0x8a, 0xe9, 0x2e, 0x95, 0xdd, 0x51, 0xdb, 0x35, 0x6a, 0x3c, 0xf6, 0x36, 0x63, + 0x02, 0x34, 0x0d, 0xd4, 0xc6, 0x36, 0x2e, 0x2b, 0x82, 0xd2, 0xd8, 0xb5, 0xa6, 0x2b, 0x44, 0xe6, + 0x34, 0xc2, 0x40, 0x61, 0x07, 0x75, 0x9e, 0xe4, 0x97, 0x2a, 0x8c, 0x4c, 0xc7, 0xcc, 0xa6, 0xd8, + 0x97, 0x25, 0xd9, 0xfa, 0xaa, 0x38, 0x3d, 0x0b, 0x77, 0x73, 0xff, 0x29, 0x07, 0x5f, 0x99, 0x7b, + 0x49, 0x38, 0x2a, 0x6d, 0x34, 0x34, 0xb7, 0xa1, 0xa3, 0xa9, 0x77, 0xcd, 0x5d, 0x09, 0xe0, 0x7f, + 0x3e, 0xf2, 0xc3, 0x6a, 0xca, 0xcc, 0x82, 0x5a, 0x76, 0x2b, 0x39, 0x49, 0xf3, 0x57, 0x75, 0x53, + 0xc2, 0x4d, 0xc0, 0x8f, 0x8c, 0x36, 0xd6, 0xcf, 0x0c, 0x41, 0xdc, 0xe2, 0x28, 0x1a, 0xa1, 0x43, + 0x0e, 0xaa, 0x94, 0x9d, 0xd6, 0x67, 0xbc, 0x30, 0x99, 0xd6, 0xac, 0x60, 0x5a, 0xab, 0x8a, 0x69, + 0x73, 0x59, 0x01, 0x88, 0x9e, 0x97, 0x49, 0x3f, 0xaf, 0xf3, 0x46, 0x19, 0xa3, 0x38, 0x23, 0x7f, + 0x49, 0xcc, 0xeb, 0x39, 0x16, 0x49, 0xe8, 0x5f, 0xe8, 0xed, 0xbd, 0xc6, 0x1e, 0x27, 0xe6, 0xba, + 0x57, 0xc4, 0x1c, 0xff, 0x55, 0x9d, 0xe7, 0x2e, 0xd0, 0xaf, 0xae, 0x6d, 0x5a, 0x36, 0x39, 0x9f, + 0xac, 0xac, 0x99, 0x15, 0x09, 0x30, 0xd9, 0x2d, 0xe9, 0x6c, 0xcb, 0x47, 0x62, 0x95, 0xf5, 0xbe, + 0x79, 0x78, 0x58, 0x00, 0xf1, 0x89, 0xc8, 0xd2, 0xbf, 0x16, 0xe2, 0x42, 0x80, 0x8f, 0xb1, 0x10, + 0x8e, 0x21, 0x4b, 0x5b, 0x86, 0x0c, 0x86, 0x27, 0x9c, 0x8c, 0x08, 0xa8, 0x4f, 0x35, 0x7e, 0xda, + 0x3b, 0x6c, 0x94, 0x55, 0xa9, 0x39, 0xad, 0x4a, 0xac, 0x5d, 0xab, 0xe0, 0x22, 0xf9, 0x01, 0x05, + 0x26, 0x73, 0x53, 0x27, 0x44, 0xa5, 0xf9, 0x7b, 0xd7, 0xa9, 0x67, 0xf7, 0x0e, 0x38, 0x49, 0xf4, + 0x57, 0x7b, 0x49, 0x34, 0xb0, 0x2a, 0x89, 0xc3, 0x20, 0x08, 0xb3, 0x72, 0xdb, 0x43, 0x1b, 0x2b, + 0x06, 0x3d, 0x4e, 0xec, 0xd3, 0x11, 0x5f, 0x26, 0x66, 0x3c, 0x1d, 0x8b, 0x14, 0x89, 0x99, 0xf5, + 0x83, 0xba, 0x19, 0x6a, 0x96, 0x26, 0x9d, 0x49, 0xd6, 0x0a, 0xf2, 0x61, 0x64, 0xa9, 0x88, 0xa1, + 0x12, 0xca, 0x9f, 0xee, 0xed, 0x0b, 0xb8, 0x47, 0x2d, 0xdd, 0xef, 0xd7, 0x44, 0x8b, 0x45, 0x61, + 0x5a, 0xbe, 0x3e, 0x9e, 0x45, 0x33, 0xe5, 0xb0, 0xa5, 0x7d, 0x22, 0xe4, 0x9b, 0x86, 0x37, 0xa7, + 0xbb, 0x79, 0x3e, 0x3b, 0x6c, 0xa4, 0x3d, 0x75, 0x5c, 0xf1, 0x8e, 0x04, 0x37, 0x3b, 0x25, 0xdd, + 0x69, 0x58, 0xbf, 0x55, 0x16, 0x8e, 0x0d, 0xb5, 0x9c, 0xca, 0x88, 0x69, 0x96, 0xd8, 0x61, 0x95, + 0x94, 0x6e, 0x67, 0x0c, 0x38, 0x91, 0xf4, 0x31, 0x4d, 0xc0, 0x94, 0x4d, 0xb6, 0xec, 0x12, 0x57, + 0x4d, 0x6c, 0x3f, 0x11, 0x65, 0x59, 0x9f, 0xa1, 0x2b, 0x8f, 0x42, 0x0e, 0xeb, 0x2f, 0xea, 0x25, + 0xf3, 0xfd, 0xe8, 0x14, 0x2d, 0xb1, 0xf3, 0x97, 0x6b, 0x50, 0x5f, 0x2b, 0x1b, 0xd4, 0x53, 0xbd, + 0xea, 0xe5, 0x28, 0x43, 0x4a, 0xe9, 0x65, 0x9a, 0x0f, 0x6d, 0x83, 0x3e, 0xf6, 0xfc, 0x44, 0xcc, + 0xeb, 0x8e, 0x99, 0x7c, 0x25, 0x86, 0x87, 0x1e, 0x4d, 0x0f, 0xc1, 0x5e, 0x0a, 0x1f, 0x7e, 0x21, + 0x11, 0xe5, 0x8a, 0x45, 0x25, 0xa2, 0xe0, 0xc3, 0x33, 0xee, 0xea, 0x24, 0x4f, 0x55, 0x93, 0x24, + 0x25, 0x41, 0xf8, 0xd8, 0x93, 0xa2, 0xb7, 0x98, 0xe9, 0xc5, 0x8c, 0x49, 0x3f, 0x30, 0xf3, 0x0c, + 0x86, 0x78, 0x53, 0x61, 0xc8, 0x81, 0x67, 0xd5, 0x55, 0xa7, 0xd8, 0x8e, 0xf5, 0x87, 0xcc, 0x6c, + 0xce, 0xec, 0x7e, 0x60, 0x96, 0x61, 0x97, 0x67, 0xf8, 0x44, 0x34, 0xe8, 0xab, 0x66, 0x9c, 0x63, + 0xcc, 0x70, 0x8b, 0x2a, 0x20, 0x7f, 0x21, 0xd2, 0x51, 0xfb, 0xaa, 0x5a, 0xc1, 0x77, 0x6b, 0xa5, + 0xed, 0x52, 0x4f, 0x80, 0x85, 0x04, 0x2a, 0x0a, 0x38, 0xe8, 0x24, 0xd3, 0xb1, 0x74, 0x63, 0x66, + 0x2c, 0xcd, 0xdb, 0x1d, 0xe6, 0xe7, 0x8d, 0x2f, 0x99, 0x54, 0xb7, 0xaa, 0x71, 0x2b, 0x21, 0xb6, + 0x31, 0x5d, 0x07, 0xf4, 0x4b, 0xc3, 0x2d, 0x31, 0xcf, 0x16, 0x01, 0x35, 0x2c, 0x29, 0x41, 0xcf, + 0x48, 0x7a, 0x8f, 0xe6, 0x58, 0x4e, 0x65, 0x49, 0x1b, 0x95, 0x0a, 0x4d, 0x01, 0xa4, 0xf5, 0x61, + 0x49, 0xa0, 0x71, 0xd2, 0x5b, 0xb2, 0x9f, 0xfe, 0x27, 0x4e, 0xe9, 0x96, 0xa6, 0xbc, 0x49, 0x49, + 0xb2, 0x07, 0xd1, 0xa3, 0x4d, 0xa9, 0xcb, 0x82, 0xf5, 0x94, 0x2a, 0xd7, 0xe6, 0x65, 0x6a, 0x74, + 0xa2, 0x70, 0xa1, 0x43, 0x4f, 0x82, 0xac, 0x7e, 0xb4, 0x2a, 0x33, 0x2c, 0x8d, 0x51, 0x77, 0x25, + 0x0a, 0x75, 0x18, 0xbf, 0x5b, 0x08, 0x8d, 0xd1, 0xf0, 0xf0, 0x1c, 0xc8, 0xff, 0x0c, 0x8c, 0x46, + 0xaa, 0x36, 0x45, 0x26, 0x74, 0xcd, 0x2b, 0x34, 0x69, 0xec, 0xa4, 0xb1, 0x72, 0x9c, 0xe6, 0xd4, + 0x31, 0x5f, 0x4a, 0x0e, 0x7c, 0xee, 0x3a, 0xa1, 0x18, 0x65, 0xfd, 0x75, 0x09, 0x01, 0x42, 0x6b, + 0xe9, 0x5a, 0x23, 0x72, 0xfb, 0x8d, 0xf0, 0xdf, 0xa8, 0xd0, 0xa1, 0x1d, 0xc5, 0xfa, 0xf6, 0x82, + 0x49, 0x9e, 0xbc, 0x0e, 0x8f, 0x43, 0xe8, 0xcf, 0x70, 0x9c, 0x9a, 0xa8, 0x4c, 0x0d, 0xe2, 0x5e, + 0x74, 0xd9, 0x4b, 0x03, 0x38, 0x76, 0xb6, 0xf9, 0xca, 0x43, 0x36, 0x78, 0x1b, 0xa9, 0x46, 0x2b, + 0x3c, 0xc8, 0xe0, 0x77, 0xb1, 0xb9, 0xfb, 0xe7, 0x35, 0x15, 0x79, 0xdb, 0xd9, 0xfd, 0x09, 0x4d, + 0x7b, 0x27, 0x4d, 0xe5, 0x68, 0x9c, 0x26, 0xea, 0x74, 0xe4, 0x84, 0x38, 0x92, 0x71, 0x65, 0xe2, + 0xba, 0x5c, 0xe7, 0x58, 0xd7, 0xd7, 0x5f, 0xf4, 0x27, 0x5d, 0x80, 0x6a, 0x9c, 0x47, 0x65, 0xb3, + 0x27, 0xb6, 0x17, 0x47, 0xe3, 0xb1, 0xf4, 0xf2, 0xa3, 0x3b, 0x55, 0x51, 0x6c, 0xc7, 0x93, 0x30, + 0x44, 0x46, 0xb7, 0xb4, 0xd6, 0x8e, 0xe0, 0x8b, 0x9d, 0x46, 0x44, 0x8f, 0x74, 0x08, 0x0e, 0x9b, + 0xaf, 0x68, 0xbb, 0x42, 0x3c, 0xa2, 0xb4, 0xef, 0xa6, 0x03, 0x6c, 0x18, 0xa9, 0x9c, 0x5c, 0xf7, + 0x43, 0xb1, 0xc8, 0x0b, 0x79, 0x78, 0xf5, 0x1e, 0xb9, 0xe0, 0x5b, 0xa9, 0xba, 0xbd, 0xc3, 0x45, + 0x53, 0xc5, 0x1b, 0x3d, 0xf5, 0xac, 0xdc, 0x0c, 0xbb, 0xd1, 0xc5, 0x9f, 0x06, 0x35, 0xe1, 0xe1, + 0x32, 0x36, 0xa9, 0xe3, 0x69, 0x85, 0x6c, 0xb3, 0x74, 0x49, 0x08, 0xf1, 0x6c, 0x76, 0x7f, 0xd4, + 0xd4, 0xc4, 0x23, 0x62, 0xd2, 0xbd, 0x0f, 0x63, 0xb5, 0x13, 0x4f, 0x55, 0x05, 0x96, 0x3f, 0xa4, + 0xae, 0xce, 0xb9, 0x5c, 0x12, 0x8b, 0xcc, 0x3b, 0xec, 0xdb, 0x20, 0xce, 0x3d, 0xb7, 0x2f, 0xe7, + 0x70, 0x81, 0x1a, 0x4d, 0x67, 0xd3, 0x09, 0xbd, 0x28, 0xcc, 0xd0, 0x54, 0x5c, 0xc2, 0x20, 0x05, + 0x31, 0x95, 0xfe, 0xb6, 0x3a, 0x36, 0x6f, 0x52, 0xe2, 0x91, 0x17, 0x4b, 0x14, 0x98, 0xd3, 0x14, + 0x18, 0x25, 0x03, 0xe3, 0x9a, 0x53, 0x93, 0xea, 0x68, 0x74, 0x13, 0xf1, 0x53, 0xea, 0x13, 0x12, + 0xdd, 0x99, 0x48, 0xb0, 0xa8, 0xc9, 0x85, 0xae, 0xc9, 0x20, 0x76, 0x46, 0x0a, 0x88, 0x98, 0x6e, + 0xa7, 0xfe, 0x4b, 0xfa, 0x90, 0x05, 0xd9, 0x96, 0x53, 0x7d, 0x99, 0x9a, 0x4f, 0x89, 0x63, 0x93, + 0x70, 0x2b, 0x84, 0x6d, 0x99, 0xae, 0x49, 0x19, 0xdf, 0x57, 0x32, 0x9c, 0x7c, 0xe4, 0x86, 0xf1, + 0xe5, 0x31, 0x0d, 0xd0, 0x9b, 0x8c, 0x8d, 0xe6, 0x43, 0xd4, 0xfc, 0x8c, 0x38, 0xc1, 0xa8, 0x67, + 0xd7, 0xae, 0x40, 0x45, 0x03, 0xbc, 0x22, 0x06, 0xb2, 0x79, 0x98, 0xba, 0x80, 0x3d, 0x1b, 0xf9, + 0x6e, 0x8c, 0x49, 0x2b, 0xd7, 0x76, 0xb6, 0x07, 0x76, 0xe0, 0xa4, 0x32, 0x74, 0x77, 0x3b, 0x47, + 0x74, 0xd4, 0x97, 0x7f, 0x1e, 0xf9, 0x61, 0xf6, 0xb9, 0x5d, 0xf1, 0x19, 0x5c, 0x50, 0xfd, 0xf9, + 0x71, 0x9d, 0x02, 0x06, 0x7f, 0x11, 0xb6, 0xa2, 0x28, 0xc0, 0xbb, 0x22, 0x60, 0x96, 0xd0, 0x66, + 0x72, 0x66, 0xd7, 0xfa, 0x9b, 0xc2, 0xe1, 0x09, 0xef, 0x83, 0xc9, 0xda, 0x36, 0xe0, 0xeb, 0x6c, + 0x06, 0xb2, 0x7d, 0x5f, 0x1c, 0x33, 0x12, 0x76, 0xc0, 0x63, 0xfd, 0x45, 0x25, 0xb0, 0x56, 0x7b, + 0xb3, 0x07, 0xab, 0xf4, 0x9f, 0xfd, 0x80, 0x46, 0xe6, 0x30, 0xf1, 0x14, 0x2b, 0x87, 0x69, 0xf7, + 0xa3, 0xd8, 0x56, 0x57, 0xb7, 0xe8, 0x9e, 0x86, 0xaa, 0x37, 0xed, 0x5e, 0x16, 0xc7, 0x66, 0x00, + 0x80, 0x5d, 0x42, 0x95, 0x9c, 0x65, 0x67, 0x22, 0xfa, 0x98, 0x9e, 0xce, 0x6d, 0xac, 0x89, 0xe9, + 0xe0, 0x43, 0x8c, 0x80, 0xfb, 0x1a, 0x5b, 0x37, 0xc3, 0x18, 0x66, 0xc5, 0x99, 0x6e, 0xec, 0x52, + 0x4e, 0x4d, 0x17, 0xba, 0xa2, 0x85, 0x75, 0x87, 0x72, 0xe4, 0xe0, 0xc1, 0x8f, 0x93, 0xdf, 0xdd, + 0x6a, 0x68, 0xdb, 0x93, 0xdb, 0x5f, 0x40, 0x9d, 0x76, 0xbc, 0x26, 0x19, 0xd6, 0x7f, 0x28, 0xa4, + 0x6f, 0xcc, 0x79, 0xcd, 0xea, 0x98, 0xe2, 0xfc, 0x86, 0x8f, 0x56, 0xd7, 0x31, 0x6d, 0x01, 0xa7, + 0x86, 0x4e, 0xcf, 0x31, 0x4e, 0xea, 0x00, 0xf3, 0xbc, 0x68, 0xf1, 0xe7, 0x16, 0xb1, 0xe1, 0xf9, + 0xde, 0xde, 0xf3, 0xb2, 0xb6, 0xb6, 0xef, 0x88, 0x36, 0x1e, 0x06, 0xca, 0x6d, 0xaa, 0x48, 0xc2, + 0xe4, 0xb9, 0xbb, 0xa5, 0xb3, 0x00, 0xab, 0xfb, 0x81, 0x58, 0x33, 0x46, 0x5e, 0xa1, 0x91, 0xdd, + 0x57, 0x44, 0x2b, 0x23, 0x2b, 0x25, 0x37, 0x8d, 0x50, 0x9d, 0xf2, 0xd0, 0x46, 0x6a, 0x72, 0xa5, + 0xbb, 0x26, 0xda, 0xd3, 0x30, 0x50, 0x3b, 0x4d, 0x9c, 0xcc, 0x9c, 0xe2, 0x24, 0xc4, 0x2e, 0x7c, + 0x6f, 0x03, 0x4f, 0x73, 0xe6, 0xad, 0xef, 0xd5, 0xcd, 0xcc, 0xde, 0x46, 0x1a, 0xc5, 0xf2, 0x93, + 0xa3, 0xf1, 0x97, 0xc5, 0x71, 0x36, 0x80, 0x4a, 0x5b, 0x01, 0x77, 0x2c, 0x60, 0x47, 0xd6, 0x73, + 0x6a, 0xe1, 0x72, 0x6f, 0xbf, 0xb9, 0x95, 0x55, 0xbc, 0xce, 0x00, 0xde, 0xcd, 0x00, 0xb0, 0xd4, + 0xe0, 0x27, 0x75, 0xe1, 0x85, 0x0a, 0xe3, 0xb9, 0xb2, 0xef, 0x86, 0x38, 0x3e, 0x6b, 0xd4, 0x14, + 0x59, 0xf1, 0x52, 0x8b, 0x54, 0x37, 0xc0, 0xca, 0xf4, 0xb5, 0xfe, 0xb9, 0x90, 0x2c, 0x28, 0x22, + 0xb8, 0x3a, 0x4d, 0x15, 0xda, 0xf2, 0x52, 0xbc, 0xe8, 0x53, 0x2c, 0x57, 0xd5, 0x1f, 0xa4, 0xcc, + 0x3f, 0x34, 0xa6, 0x75, 0xa5, 0xa9, 0x1d, 0x34, 0xf9, 0xd1, 0x38, 0xf0, 0x5d, 0xbe, 0x0d, 0xa4, + 0x2e, 0x55, 0x2e, 0x40, 0x8c, 0xaa, 0xe4, 0x93, 0x85, 0xeb, 0xf4, 0x4c, 0xca, 0x71, 0xc6, 0xfb, + 0x11, 0x45, 0xc9, 0xfa, 0xe3, 0xc2, 0xa1, 0x27, 0x0d, 0x7c, 0x38, 0x46, 0x9a, 0x7a, 0x07, 0xb9, + 0x3c, 0x5a, 0xc1, 0xfb, 0xb7, 0xc4, 0xca, 0x84, 0x01, 0x64, 0xcb, 0x2b, 0xeb, 0x95, 0x39, 0x4b, + 0x4f, 0xfd, 0x6f, 0x33, 0xf2, 0xe7, 0xc5, 0x4a, 0xa1, 0xe1, 0x60, 0x8b, 0xf8, 0xfd, 0x42, 0x8a, + 0xbd, 0x48, 0x96, 0x69, 0x76, 0x4d, 0x53, 0x9a, 0xcf, 0xa8, 0x3f, 0x87, 0x2e, 0xb2, 0x3e, 0xf2, + 0x48, 0xb9, 0xe6, 0xa1, 0x9c, 0x07, 0x2b, 0xc2, 0x56, 0x42, 0xfa, 0x20, 0xb2, 0xa9, 0xbd, 0x7b, + 0x41, 0x3c, 0x56, 0x6c, 0x39, 0x18, 0xfa, 0x4f, 0x99, 0x1b, 0x07, 0x58, 0x0c, 0xfe, 0x83, 0x4f, + 0x2b, 0x12, 0xeb, 0x6d, 0xf1, 0x9c, 0x79, 0xe6, 0x82, 0x71, 0xd0, 0x5d, 0x10, 0xdc, 0xc0, 0xd9, + 0x85, 0x1e, 0xd1, 0x24, 0xbe, 0xce, 0xce, 0x19, 0x0a, 0x9b, 0xf2, 0xd3, 0x94, 0x83, 0xcd, 0x47, + 0x4a, 0x8b, 0xd6, 0x4f, 0xeb, 0x66, 0x2c, 0x5c, 0x86, 0x9f, 0x29, 0x3b, 0x8c, 0x2f, 0x5f, 0x7c, + 0xcd, 0xea, 0x98, 0xa7, 0x6e, 0xdf, 0xf2, 0x91, 0xa8, 0x10, 0xf5, 0x28, 0x51, 0x29, 0x8d, 0xf2, + 0xa5, 0xbb, 0x86, 0x3e, 0x58, 0xf3, 0x61, 0x1f, 0xa7, 0xc4, 0xa9, 0x3a, 0x6b, 0xe3, 0x8a, 0x0f, + 0x75, 0x51, 0x57, 0x1d, 0xb6, 0xc1, 0xdc, 0xec, 0x87, 0xe5, 0xbb, 0x22, 0xbb, 0x2d, 0x6f, 0x8b, + 0x15, 0xae, 0xc4, 0xd7, 0xbe, 0xe4, 0xdc, 0x14, 0x4b, 0x66, 0x2d, 0x88, 0xea, 0xf2, 0xbb, 0xeb, + 0xa2, 0x49, 0xb1, 0x4a, 0x76, 0xc3, 0x3c, 0x63, 0x83, 0x51, 0x08, 0x5f, 0xd7, 0xf7, 0xff, 0xe8, + 0xc0, 0x47, 0x4d, 0x95, 0xdd, 0x39, 0x5f, 0xb1, 0x3e, 0xaa, 0x64, 0xd0, 0xda, 0x78, 0x4c, 0x99, + 0x65, 0x00, 0x3d, 0x92, 0x9e, 0xef, 0xa8, 0x42, 0x08, 0xaa, 0xbb, 0x8f, 0x82, 0x44, 0x49, 0x15, + 0xfc, 0x1c, 0xa8, 0x02, 0x55, 0xfc, 0x89, 0x95, 0xed, 0x61, 0xb0, 0xcb, 0xe7, 0xcb, 0x41, 0x20, + 0x75, 0x19, 0x17, 0x78, 0x3c, 0xd4, 0x4e, 0xdb, 0xaf, 0x76, 0x9a, 0x17, 0xac, 0xff, 0xd7, 0xac, + 0xe4, 0x9d, 0x9a, 0x3a, 0xe3, 0xdd, 0x05, 0xd1, 0x84, 0xd5, 0xe9, 0x33, 0xc4, 0x17, 0x7b, 0xfb, + 0x0f, 0xc1, 0x8a, 0x92, 0x2a, 0xb2, 0x93, 0x0b, 0xdd, 0xfd, 0x5e, 0x43, 0x34, 0xb0, 0x43, 0x89, + 0x6a, 0x78, 0x30, 0x0c, 0x4c, 0x1b, 0x44, 0x59, 0xa9, 0x0e, 0xb4, 0xd0, 0x2b, 0x03, 0x18, 0x55, + 0x09, 0xdd, 0xd2, 0x77, 0xb6, 0xb1, 0xb2, 0x41, 0x17, 0x3c, 0xa0, 0x0c, 0x94, 0x56, 0x8b, 0xa7, + 0xdd, 0x58, 0x20, 0xc1, 0x96, 0x42, 0x59, 0xba, 0xec, 0xbe, 0xbd, 0x07, 0x1e, 0x23, 0x56, 0x29, + 0x4a, 0x4f, 0xf9, 0xb3, 0x58, 0x45, 0x4d, 0x5f, 0xd4, 0x5d, 0x52, 0x96, 0x0d, 0x2c, 0x47, 0x29, + 0xf4, 0xa7, 0x0b, 0x95, 0x4a, 0x34, 0x61, 0x69, 0x59, 0xf3, 0xd8, 0xa1, 0x3a, 0xd3, 0x25, 0x7d, + 0xd1, 0x15, 0x13, 0x8e, 0xfa, 0x23, 0x92, 0x7a, 0x59, 0x8b, 0x04, 0x7e, 0x50, 0x9d, 0x57, 0xb2, + 0x05, 0x6b, 0x86, 0x70, 0x45, 0x10, 0x78, 0x88, 0x19, 0xb1, 0xec, 0x28, 0xc4, 0xca, 0x85, 0x14, + 0x9c, 0x97, 0x11, 0x79, 0xa8, 0x0b, 0xed, 0xcb, 0xa2, 0xe9, 0x05, 0xae, 0x4e, 0x27, 0x9e, 0x39, + 0x20, 0x23, 0x7a, 0x57, 0x6f, 0xad, 0x77, 0x5f, 0x14, 0x0d, 0xf8, 0xaf, 0x4c, 0xf2, 0x02, 0xf1, + 0xd8, 0x27, 0x3b, 0x53, 0x28, 0xd2, 0xe1, 0x8f, 0x19, 0xe8, 0xd2, 0x78, 0xeb, 0xbc, 0x29, 0x3f, + 0xe5, 0xce, 0xb3, 0x4a, 0x48, 0xac, 0x57, 0x0b, 0xef, 0x38, 0x84, 0xfe, 0x3e, 0x93, 0x5c, 0x34, + 0x4d, 0xd4, 0x74, 0xf7, 0x99, 0xd3, 0x5c, 0x31, 0xb3, 0xdc, 0x1b, 0x06, 0x81, 0x78, 0x0f, 0xe0, + 0xf2, 0x94, 0x12, 0x41, 0xb0, 0xe0, 0x8c, 0xa5, 0x86, 0xa9, 0xf1, 0x19, 0xf1, 0xd2, 0xbe, 0x30, + 0x66, 0x22, 0xf0, 0xad, 0x82, 0x9f, 0xf9, 0xf0, 0xfa, 0xc6, 0x43, 0x2a, 0x8f, 0xbd, 0x0e, 0xee, + 0x83, 0x3a, 0xdd, 0x9e, 0x4a, 0xa4, 0x00, 0x43, 0xb0, 0x26, 0xc1, 0x4e, 0xfc, 0xaf, 0xeb, 0x2a, + 0x16, 0xd0, 0xdd, 0xd8, 0xd9, 0xb1, 0xf3, 0xe6, 0x86, 0x16, 0x1e, 0xbc, 0xd9, 0x4d, 0x77, 0xba, + 0x9b, 0xf9, 0x03, 0x09, 0x23, 0x2a, 0x39, 0x1c, 0x8d, 0x55, 0x00, 0xa7, 0xe1, 0x19, 0x79, 0x86, + 0xe7, 0xc4, 0x53, 0x5a, 0xac, 0x78, 0x33, 0xda, 0x0d, 0x5d, 0xe3, 0x9a, 0xba, 0x2a, 0x57, 0x79, + 0x5e, 0x1c, 0x99, 0xea, 0xc5, 0xc2, 0xff, 0xa6, 0x38, 0xbf, 0x7a, 0xf9, 0xfc, 0xe5, 0x8b, 0x97, + 0x56, 0x2f, 0x5f, 0x30, 0x0f, 0xb2, 0x16, 0xb5, 0x3b, 0xe8, 0x3a, 0xa1, 0xad, 0x9e, 0x09, 0xe1, + 0xfa, 0x15, 0xeb, 0xf7, 0x0a, 0x09, 0xbd, 0x12, 0x21, 0xf6, 0xa8, 0xbc, 0x30, 0xd7, 0x58, 0xd7, + 0xc5, 0x23, 0x78, 0xb3, 0x76, 0x98, 0xa6, 0xe3, 0x5c, 0xff, 0xf1, 0x97, 0x3d, 0x8c, 0x92, 0x54, + 0xed, 0x01, 0x58, 0x32, 0x81, 0x4d, 0x78, 0xd5, 0x36, 0x2b, 0xb7, 0xd8, 0xda, 0xc6, 0x5b, 0xc9, + 0x9e, 0x3e, 0xd5, 0xa1, 0x2b, 0xf0, 0x1a, 0x14, 0xe7, 0x03, 0xe8, 0x3e, 0x85, 0x42, 0x9c, 0xe7, + 0xa4, 0x77, 0x14, 0xac, 0xdf, 0x2e, 0xf8, 0x6b, 0x19, 0xf6, 0xeb, 0xd1, 0x68, 0xe4, 0xa7, 0xed, + 0x9e, 0x68, 0x61, 0x5f, 0x6d, 0x1d, 0x9f, 0xee, 0xcd, 0xec, 0x8a, 0x87, 0x74, 0xb2, 0xeb, 0x88, + 0x26, 0xfe, 0x5f, 0xb9, 0xde, 0xf2, 0x6d, 0x44, 0x73, 0xfd, 0x8d, 0xac, 0x78, 0x66, 0xb2, 0x99, + 0x73, 0x7d, 0xa5, 0xc8, 0x61, 0x2e, 0xcd, 0xfd, 0x6e, 0xa1, 0x40, 0xb4, 0x84, 0x45, 0x46, 0xf0, + 0x8b, 0x45, 0xc4, 0x5f, 0xec, 0xed, 0x3b, 0x84, 0x17, 0xf0, 0xd6, 0xc7, 0x59, 0x80, 0x75, 0xcb, + 0x74, 0x08, 0x61, 0x1e, 0x04, 0xb5, 0x3e, 0x84, 0x40, 0xbe, 0xd0, 0xb7, 0xa6, 0x05, 0x9a, 0xa5, + 0x9e, 0x6a, 0x68, 0x19, 0xe2, 0x32, 0x98, 0xc0, 0xfc, 0x5c, 0xe3, 0x74, 0x49, 0xc1, 0x1e, 0xc4, + 0x4e, 0x98, 0xf4, 0x65, 0xfc, 0x8e, 0xbe, 0x7f, 0x6e, 0xdd, 0x98, 0x29, 0x79, 0xd7, 0xfd, 0x90, + 0x8a, 0xb1, 0x0e, 0x26, 0x79, 0x96, 0x5d, 0x9a, 0xea, 0xaa, 0xc4, 0x37, 0x50, 0x0e, 0xa2, 0xcb, + 0xc6, 0xc9, 0x4c, 0x57, 0xb4, 0xfd, 0xc4, 0xce, 0xfc, 0x43, 0x8f, 0x60, 0xb0, 0x20, 0x5b, 0xef, + 0x94, 0x30, 0x35, 0x27, 0xd8, 0x43, 0x47, 0xa6, 0x67, 0xb1, 0x36, 0x4a, 0xa8, 0xc2, 0xe6, 0x80, + 0x60, 0x70, 0x5f, 0xb8, 0x1e, 0xc5, 0x68, 0x61, 0xf9, 0x26, 0x29, 0x29, 0x36, 0xd5, 0x90, 0xa9, + 0x9b, 0x59, 0xf4, 0x32, 0x4e, 0x48, 0xf9, 0x4d, 0xac, 0x20, 0x94, 0x7d, 0xff, 0x23, 0x15, 0xe6, + 0x2f, 0x58, 0x7f, 0x54, 0x17, 0x2f, 0xec, 0x0d, 0x35, 0x43, 0xf3, 0x33, 0x45, 0xc9, 0x7a, 0xa5, + 0x77, 0xb0, 0x71, 0x24, 0x5e, 0x54, 0xcb, 0x57, 0x9a, 0x1e, 0xdc, 0xcc, 0xee, 0x8f, 0x6b, 0x4a, + 0xec, 0x0e, 0x40, 0xe5, 0x69, 0xb5, 0x29, 0x9a, 0xc6, 0xa6, 0xce, 0x02, 0x15, 0xed, 0x6a, 0x4b, + 0x17, 0x0d, 0x56, 0xb0, 0x68, 0x8e, 0xec, 0xc3, 0x89, 0x2a, 0xa3, 0x38, 0xaf, 0x2f, 0x5e, 0x18, + 0x68, 0x83, 0x03, 0xe6, 0xc9, 0x8f, 0x94, 0xbd, 0x5c, 0xf8, 0xe6, 0x8f, 0x3a, 0x0b, 0xff, 0xfb, + 0x47, 0x9d, 0xc3, 0xd6, 0x97, 0x0b, 0x1b, 0x1f, 0xb0, 0x58, 0xb9, 0x09, 0x8f, 0x20, 0x41, 0x98, + 0x16, 0x04, 0xfb, 0x0a, 0x6e, 0x83, 0x17, 0x98, 0x76, 0xd0, 0xfa, 0x7e, 0xdd, 0x3c, 0xe3, 0x2b, + 0x00, 0xdf, 0x43, 0x7a, 0xca, 0x0a, 0x5b, 0xd8, 0x7f, 0x1a, 0xd5, 0xfb, 0x4f, 0x73, 0x4a, 0xb5, + 0x5b, 0x15, 0x44, 0x66, 0xdf, 0xaa, 0x9a, 0x9a, 0x6c, 0x6d, 0x4d, 0x5b, 0xbe, 0x30, 0x6d, 0xcb, + 0x17, 0xa7, 0x6c, 0xb9, 0xa8, 0xb0, 0xe5, 0x4b, 0xd3, 0xb6, 0x7c, 0x59, 0xc3, 0xca, 0xde, 0xaa, + 0xe2, 0x47, 0x18, 0xac, 0xf7, 0x4b, 0x76, 0xfc, 0x16, 0x3e, 0x7f, 0xa0, 0x69, 0x3f, 0xfb, 0x15, + 0x20, 0xf8, 0xe2, 0x8c, 0xb2, 0xba, 0x4e, 0xbe, 0xf5, 0xca, 0xb9, 0xe0, 0x65, 0xe5, 0x18, 0x37, + 0xe8, 0xa2, 0xfe, 0x59, 0xd3, 0x73, 0xca, 0xc1, 0xef, 0x71, 0xdb, 0xe3, 0x86, 0x59, 0x94, 0xa8, + 0x10, 0xb9, 0xa6, 0x91, 0x06, 0xcd, 0xa8, 0xbe, 0xf3, 0xae, 0x08, 0x17, 0x93, 0x1d, 0x64, 0xe3, + 0xf4, 0x3f, 0x6b, 0xe2, 0xcc, 0x01, 0x20, 0x1d, 0xa4, 0x62, 0x23, 0xcb, 0xbc, 0x9c, 0x13, 0x47, + 0xab, 0x1e, 0xfb, 0x52, 0x29, 0xe7, 0xc7, 0x7b, 0xd3, 0xe0, 0xad, 0xc0, 0xa4, 0xc0, 0x7b, 0xe8, + 0x55, 0x52, 0x71, 0x3e, 0xfb, 0x4a, 0xc8, 0xb8, 0xa1, 0x93, 0xd8, 0x3b, 0xd4, 0xae, 0xc2, 0x19, + 0xf0, 0x1f, 0x36, 0x9d, 0x80, 0x2a, 0x2b, 0xea, 0xba, 0x58, 0xc1, 0x9d, 0xc4, 0x31, 0xa5, 0x45, + 0x1b, 0x3a, 0xe5, 0xaf, 0xba, 0xa0, 0xf8, 0x50, 0x59, 0x7b, 0x53, 0xdd, 0xd6, 0x39, 0x5e, 0xa8, + 0x6b, 0x37, 0xa6, 0x02, 0x6d, 0xa4, 0x2a, 0x56, 0x4e, 0x37, 0xaa, 0xeb, 0x57, 0x59, 0x5e, 0x3d, + 0x51, 0x87, 0x31, 0xf0, 0x29, 0x00, 0x2b, 0xa4, 0x0c, 0x9c, 0x67, 0x46, 0xf9, 0x0a, 0x1c, 0xd7, + 0x42, 0x27, 0xe8, 0x97, 0x33, 0x56, 0x1a, 0xa4, 0x5d, 0x80, 0x89, 0xf7, 0x41, 0xa3, 0x18, 0x10, + 0xec, 0x4f, 0xc0, 0x17, 0x32, 0x1d, 0x48, 0x45, 0xe9, 0x9b, 0x57, 0xb5, 0x90, 0xfc, 0x66, 0xad, + 0x62, 0x1a, 0x2d, 0x83, 0x67, 0x0a, 0x81, 0xd6, 0xc9, 0xde, 0xac, 0x8e, 0x14, 0x5e, 0x3d, 0x2d, + 0x0e, 0x67, 0x6f, 0xbd, 0x6c, 0x3a, 0xa9, 0x3b, 0xd4, 0xa6, 0x5a, 0x3d, 0x83, 0xd3, 0x5d, 0xe3, + 0x28, 0xab, 0xcc, 0x6b, 0x7a, 0xe2, 0x8c, 0x0e, 0x08, 0x6c, 0xf3, 0xd9, 0x00, 0x2a, 0xe5, 0xe4, + 0xe6, 0xf5, 0xfb, 0xeb, 0x0a, 0xdb, 0x5f, 0xa9, 0x9b, 0x2a, 0x93, 0x21, 0xa1, 0xa4, 0xe8, 0x95, + 0x02, 0xba, 0xa7, 0x7a, 0x33, 0x7b, 0x12, 0xbe, 0xf8, 0xe0, 0x12, 0xee, 0x39, 0x2a, 0x69, 0xaf, + 0xee, 0xfe, 0xea, 0xd6, 0x31, 0xd6, 0x73, 0xab, 0x63, 0xbb, 0x95, 0x2e, 0x78, 0x30, 0xb3, 0x70, + 0x2f, 0xd2, 0x9f, 0x71, 0x7f, 0x03, 0x6c, 0x91, 0x3a, 0x28, 0x51, 0x59, 0x95, 0x17, 0xf6, 0x46, + 0xa6, 0xb7, 0xc1, 0xdd, 0xbb, 0xe7, 0xc4, 0xbc, 0xfa, 0x93, 0x72, 0x27, 0x8a, 0x00, 0x85, 0x7c, + 0x8a, 0x6a, 0xdb, 0xda, 0x66, 0x5d, 0x23, 0x73, 0xfe, 0x29, 0x30, 0xe7, 0x9f, 0xb2, 0xbe, 0x50, + 0xb8, 0x67, 0xca, 0xd9, 0x0d, 0x93, 0x9d, 0x78, 0x7a, 0x92, 0xdd, 0x72, 0xd4, 0x0f, 0x7c, 0x40, + 0x88, 0x8e, 0xc5, 0x19, 0x5c, 0x16, 0x8d, 0x41, 0xb9, 0x12, 0xbf, 0x7f, 0x2c, 0x5c, 0x90, 0x2b, + 0x40, 0x53, 0xe4, 0x7e, 0x03, 0xdf, 0xa6, 0xa2, 0x66, 0x4d, 0x72, 0x73, 0x95, 0x15, 0x23, 0x7a, + 0xaa, 0x8d, 0x6c, 0x9b, 0x1a, 0x59, 0x22, 0xbf, 0xf9, 0xa5, 0xc8, 0x82, 0x2f, 0x8a, 0x79, 0x3d, + 0xbc, 0xea, 0xb6, 0xe6, 0x0c, 0x4e, 0x2c, 0x89, 0x06, 0xec, 0x0a, 0x6a, 0xd7, 0x05, 0xee, 0x6d, + 0x4e, 0xfa, 0x7d, 0x95, 0x77, 0x5f, 0xc6, 0x72, 0x5b, 0xc3, 0x2f, 0xbd, 0x77, 0x73, 0x7d, 0x43, + 0xe9, 0xd7, 0x86, 0x4f, 0xef, 0xb4, 0x30, 0xd5, 0xf0, 0x49, 0x28, 0xfc, 0x5d, 0xa9, 0x69, 0x78, + 0xa0, 0x8c, 0xda, 0x4b, 0x52, 0x01, 0x4b, 0x55, 0x9d, 0x74, 0x3a, 0xe4, 0x19, 0x71, 0x42, 0x39, + 0x30, 0x0a, 0x5d, 0xb3, 0x4b, 0x43, 0xdf, 0x84, 0xc0, 0x40, 0x3c, 0x07, 0xe0, 0x80, 0xe6, 0xe8, + 0x32, 0xbc, 0xa7, 0xc5, 0x71, 0x8e, 0xd2, 0xcd, 0xe1, 0xdc, 0x81, 0xbc, 0x03, 0xeb, 0x67, 0x0d, + 0x33, 0xe2, 0x9d, 0x5e, 0x82, 0x62, 0xd5, 0x3e, 0xf6, 0x62, 0xc6, 0x12, 0xeb, 0xb3, 0x8d, 0x09, + 0xe3, 0xfe, 0xf9, 0x3c, 0x89, 0xa6, 0x17, 0xc5, 0xf9, 0xcf, 0x73, 0xbd, 0xfd, 0x91, 0xd2, 0xd2, + 0xc0, 0xdf, 0xda, 0x57, 0xc4, 0x12, 0xd2, 0x40, 0xc3, 0xe1, 0xf3, 0x89, 0x57, 0x0f, 0x02, 0x07, + 0xf4, 0x47, 0xc1, 0x80, 0x65, 0x1a, 0xa8, 0x22, 0x38, 0x85, 0xee, 0x9c, 0xe6, 0x86, 0xf1, 0x59, + 0x63, 0xae, 0xba, 0x90, 0x0f, 0xd0, 0xbd, 0x23, 0x56, 0x8a, 0x68, 0xe1, 0xf1, 0x2a, 0x37, 0xec, + 0x27, 0x6a, 0x58, 0xdb, 0x25, 0xa5, 0x97, 0xd8, 0xf9, 0x0b, 0x1d, 0x0b, 0xdd, 0xeb, 0x62, 0x31, + 0x47, 0xaf, 0x14, 0xdb, 0x3f, 0x02, 0x1c, 0xeb, 0x2f, 0x0b, 0x07, 0x18, 0x48, 0x8a, 0x7b, 0x71, + 0xe4, 0x4d, 0xdc, 0xd4, 0xd4, 0xef, 0xb7, 0xa7, 0x14, 0xb2, 0x4c, 0xbf, 0xe9, 0x41, 0x3d, 0x43, + 0x4f, 0xdb, 0x97, 0x94, 0x01, 0xe5, 0x2b, 0x30, 0x2f, 0xed, 0x3f, 0x58, 0x99, 0xb2, 0x0a, 0x23, + 0xd2, 0x30, 0xd3, 0x4f, 0x78, 0xdf, 0x55, 0x1f, 0xc3, 0x92, 0x60, 0x77, 0xd7, 0xc5, 0xbc, 0x1e, + 0x5b, 0xa2, 0x0a, 0xbf, 0x83, 0x87, 0xef, 0x70, 0x98, 0x9e, 0x0d, 0x10, 0x85, 0x12, 0x86, 0x2a, + 0xb7, 0xca, 0xc4, 0xbd, 0x28, 0x96, 0x4c, 0xec, 0x2b, 0x58, 0x55, 0x09, 0xcc, 0xfa, 0x83, 0x66, + 0x59, 0xef, 0x0b, 0x4b, 0xcb, 0xcc, 0x9b, 0xb9, 0x9b, 0xbc, 0xdc, 0xdb, 0x77, 0x84, 0x49, 0x0d, + 0x7d, 0x12, 0x4c, 0x2b, 0xd3, 0xef, 0x4a, 0x7c, 0xce, 0xe0, 0x0f, 0x6f, 0x0b, 0xbd, 0x03, 0x40, + 0x35, 0x97, 0x08, 0xee, 0xab, 0x86, 0x9c, 0x2d, 0x95, 0x75, 0xae, 0xca, 0x90, 0x67, 0x89, 0x46, + 0x5d, 0xc1, 0x9d, 0x99, 0xd4, 0xb9, 0xec, 0x6e, 0x16, 0xfa, 0xb2, 0x78, 0x32, 0x4c, 0x9e, 0xf4, + 0xbc, 0xf6, 0xb9, 0x73, 0xaf, 0x97, 0x0a, 0xe3, 0xbb, 0xdf, 0xaa, 0xcd, 0xe4, 0xd7, 0x0c, 0x29, + 0x86, 0x66, 0x3c, 0xed, 0xa6, 0xd7, 0xc8, 0x72, 0x39, 0xd6, 0xf6, 0xb8, 0x59, 0xb2, 0xc7, 0x59, + 0xb1, 0xab, 0xc9, 0x64, 0x46, 0x12, 0x7c, 0xda, 0x1c, 0xb7, 0xee, 0xee, 0xbe, 0x2c, 0xff, 0x04, + 0xf1, 0xd1, 0x53, 0xcf, 0x65, 0x61, 0x13, 0xef, 0xb3, 0xd7, 0xcb, 0xba, 0xb8, 0x46, 0x32, 0x46, + 0x4f, 0x2b, 0x69, 0x5d, 0xcc, 0xf7, 0xa8, 0x7c, 0xab, 0x65, 0xef, 0x21, 0x93, 0x07, 0x3c, 0xf7, + 0x7d, 0x66, 0x0f, 0x40, 0x4a, 0x0e, 0xef, 0x88, 0x27, 0xb4, 0xa9, 0x32, 0x65, 0x59, 0x0b, 0xe6, + 0x6b, 0xbd, 0x7d, 0x41, 0x68, 0x11, 0xe2, 0x87, 0xa2, 0x4e, 0xe6, 0xf0, 0x3c, 0x19, 0xfa, 0x74, + 0xe7, 0x30, 0x7b, 0xe9, 0x69, 0xa5, 0x7d, 0x5d, 0x1c, 0x41, 0xc3, 0x59, 0x9c, 0xaa, 0x31, 0x95, + 0xe0, 0x9d, 0x35, 0x15, 0x3a, 0xdf, 0x34, 0xcd, 0x09, 0x86, 0x53, 0x9c, 0x82, 0x24, 0xb5, 0x7b, + 0x49, 0x2c, 0x17, 0x30, 0x3a, 0xa8, 0xe2, 0x76, 0x5f, 0x13, 0x0b, 0x19, 0xfc, 0x83, 0x98, 0x0d, + 0xeb, 0x6a, 0x29, 0x04, 0xba, 0x41, 0x37, 0xde, 0xd5, 0xd1, 0x49, 0xfb, 0x05, 0x88, 0xe5, 0xdc, + 0x28, 0x4c, 0x75, 0x81, 0xcd, 0xdc, 0x9b, 0x47, 0xcf, 0xbd, 0x71, 0xfe, 0xfc, 0xc5, 0x4b, 0xe7, + 0xcf, 0x9f, 0xbd, 0xf4, 0xfa, 0xa5, 0xb3, 0x97, 0x2f, 0x5c, 0x38, 0x77, 0xf1, 0xdc, 0x05, 0xeb, + 0x67, 0x35, 0x73, 0x93, 0x2d, 0x83, 0xd9, 0x33, 0x9e, 0x05, 0xf9, 0xc2, 0x48, 0xb1, 0xae, 0x6f, + 0xa4, 0x15, 0xee, 0xfc, 0xe1, 0xe1, 0x01, 0xd8, 0x44, 0xe3, 0x66, 0x96, 0x2e, 0xea, 0xc2, 0x52, + 0x2f, 0xbc, 0x7b, 0x12, 0xc5, 0x79, 0x7d, 0x56, 0x1e, 0xf0, 0xce, 0xe9, 0x72, 0x03, 0xac, 0x9a, + 0xa7, 0xd7, 0xda, 0x3c, 0x23, 0x1c, 0x9e, 0xd7, 0x61, 0x05, 0xdd, 0xed, 0x06, 0x5f, 0xc1, 0xdd, + 0x32, 0x54, 0x99, 0xb6, 0x73, 0xec, 0x0b, 0x11, 0x4d, 0xe4, 0xe1, 0xb1, 0xe5, 0xd0, 0x39, 0xa7, + 0xee, 0x6d, 0xad, 0x4f, 0xe7, 0x69, 0x60, 0xa7, 0x1d, 0x04, 0x94, 0xf4, 0x21, 0x7d, 0xdb, 0x3f, + 0x21, 0x60, 0xfd, 0xb8, 0x36, 0x9d, 0x97, 0x29, 0x42, 0xf9, 0x85, 0x12, 0x00, 0xc6, 0x29, 0xdb, + 0xc1, 0x32, 0xcd, 0x53, 0x69, 0x82, 0xb9, 0x3d, 0xd2, 0x29, 0xf3, 0x2a, 0xb9, 0x5e, 0xcc, 0x05, + 0x6e, 0x0c, 0x9d, 0x58, 0x1e, 0x30, 0xc9, 0x63, 0x7d, 0xa5, 0x44, 0xbc, 0x6c, 0xf0, 0x3e, 0xef, + 0xfd, 0xe5, 0x22, 0x58, 0xdf, 0x43, 0x04, 0x3f, 0x6b, 0xde, 0x33, 0xbf, 0x23, 0x77, 0x28, 0x96, + 0xff, 0x82, 0xa4, 0xb7, 0xcd, 0x26, 0xa1, 0x0f, 0x36, 0xa7, 0x80, 0x5c, 0xfe, 0x0c, 0x2c, 0x23, + 0xb7, 0x6a, 0xfa, 0xf2, 0xc6, 0x70, 0xd4, 0x60, 0x0c, 0x99, 0x2b, 0xc0, 0x58, 0xaf, 0x9b, 0x15, + 0xbf, 0x6b, 0xb7, 0xe9, 0x44, 0xc7, 0x09, 0xef, 0xf6, 0xfb, 0xbe, 0x2b, 0xe3, 0x24, 0xab, 0x7b, + 0x44, 0x51, 0x85, 0x76, 0x75, 0xaf, 0xb1, 0x6f, 0x66, 0x10, 0xa6, 0x06, 0xed, 0x49, 0x8a, 0x32, + 0xc0, 0xac, 0x48, 0x34, 0xe2, 0xd1, 0xe6, 0xc3, 0x0b, 0xd6, 0xff, 0x2d, 0xb8, 0xee, 0x34, 0x91, + 0xba, 0xa5, 0x8b, 0xef, 0xf6, 0xbc, 0xe3, 0xe3, 0x89, 0x36, 0xdd, 0xcf, 0xf0, 0xf5, 0x4b, 0x49, + 0x5c, 0x01, 0xf8, 0xa6, 0x68, 0xdc, 0xcc, 0xee, 0xf8, 0x9a, 0xde, 0xd1, 0x0c, 0x10, 0xbd, 0x9b, + 0xde, 0x4d, 0x75, 0x37, 0xb6, 0x7b, 0x52, 0x88, 0xfc, 0xd7, 0xd4, 0xcb, 0x37, 0xd6, 0x9f, 0xd4, + 0xcd, 0xb3, 0x99, 0x19, 0xf0, 0x32, 0x0a, 0xdc, 0xc5, 0x6b, 0x99, 0xfc, 0xb7, 0x46, 0xe7, 0xad, + 0xde, 0x81, 0x87, 0xf7, 0xb0, 0xed, 0x01, 0x9e, 0xca, 0x65, 0xd8, 0xfd, 0x69, 0x4d, 0x1c, 0x99, + 0x6a, 0xad, 0x24, 0xb4, 0x81, 0x39, 0xd3, 0xf8, 0x4b, 0xa2, 0x65, 0xbe, 0x2a, 0x74, 0xf3, 0xe3, + 0xe0, 0x41, 0x2d, 0x19, 0x52, 0x67, 0xc5, 0xb2, 0xf9, 0x9b, 0x4e, 0x1d, 0xa9, 0x96, 0x19, 0x1d, + 0x78, 0xc2, 0x68, 0x1e, 0x77, 0x59, 0x43, 0x8d, 0xae, 0x99, 0x6a, 0x74, 0x15, 0x70, 0xe7, 0x27, + 0xc5, 0xf1, 0x21, 0xf1, 0xfc, 0x2e, 0xa8, 0xe4, 0x32, 0x2e, 0xe3, 0x2e, 0x68, 0xc9, 0x6c, 0x58, + 0xff, 0xa7, 0x69, 0x3e, 0x9d, 0x82, 0x32, 0x68, 0xdc, 0xfe, 0x2e, 0x4b, 0x2d, 0x1a, 0xcb, 0x11, + 0x04, 0xa2, 0x7c, 0xfd, 0xfd, 0xba, 0x91, 0x84, 0xa0, 0x67, 0x42, 0x9d, 0xd0, 0x2e, 0x3e, 0xc0, + 0xc0, 0xd6, 0xfb, 0xac, 0x58, 0xa4, 0xb5, 0xd0, 0x99, 0x7a, 0x93, 0x92, 0x50, 0x66, 0x86, 0x24, + 0x9b, 0x53, 0x51, 0x04, 0xac, 0xe7, 0x79, 0xb1, 0xc4, 0xef, 0x28, 0x20, 0x2c, 0x7e, 0xde, 0xa1, + 0x78, 0x40, 0x93, 0x8f, 0xc1, 0xa2, 0x8b, 0x75, 0xea, 0xd6, 0x7e, 0x59, 0xcc, 0xc9, 0x6d, 0x7c, + 0x11, 0x5f, 0x55, 0x03, 0x74, 0x2b, 0x07, 0x5c, 0xc3, 0x2e, 0xed, 0x73, 0x62, 0xc5, 0x09, 0x43, + 0x18, 0xe7, 0x52, 0x55, 0x14, 0x9e, 0x23, 0xed, 0x33, 0xa4, 0x7b, 0x4e, 0x2c, 0x64, 0x08, 0xea, + 0x8b, 0xd5, 0xc5, 0x17, 0x2b, 0xd0, 0xd8, 0xf2, 0x6d, 0x6d, 0xce, 0x38, 0x74, 0xef, 0x09, 0x61, + 0xe0, 0x77, 0x28, 0xbf, 0x56, 0x92, 0xf1, 0x82, 0xef, 0x9e, 0xe7, 0x87, 0x2e, 0x58, 0x5b, 0x9c, + 0x66, 0xb1, 0x3c, 0x0e, 0x51, 0x2f, 0xf3, 0xaa, 0x70, 0xe0, 0x03, 0xd1, 0xe2, 0x05, 0xc0, 0x7e, + 0x39, 0x30, 0xea, 0xaf, 0x04, 0xad, 0x5c, 0x57, 0x72, 0x29, 0x60, 0xd9, 0xf5, 0xe3, 0x46, 0xb9, + 0x4e, 0xb9, 0xa9, 0x2f, 0xd9, 0x7c, 0x6d, 0x92, 0xa4, 0xf6, 0x38, 0xa2, 0x1b, 0x6e, 0x5c, 0x5a, + 0x10, 0x9b, 0xf2, 0xc0, 0xf7, 0xad, 0xf1, 0xca, 0xc7, 0xd4, 0xfb, 0x55, 0x98, 0xcf, 0xc6, 0x42, + 0x68, 0x7e, 0x8b, 0x24, 0x7b, 0xd4, 0xb0, 0xc5, 0xcb, 0xe4, 0x5b, 0x1d, 0x9c, 0x4d, 0x30, 0x9e, + 0xf4, 0x36, 0x1e, 0x0a, 0xce, 0x33, 0xfa, 0xf3, 0xd6, 0xaf, 0xd6, 0xa6, 0x2f, 0x87, 0xc3, 0xcf, + 0x9b, 0xb0, 0xf3, 0xe2, 0x93, 0x82, 0xa6, 0x30, 0xe2, 0x7b, 0x78, 0xfb, 0x61, 0x00, 0x1b, 0x3e, + 0x3d, 0x9b, 0x57, 0x7e, 0x91, 0xa2, 0xa1, 0x33, 0x97, 0x85, 0x5b, 0x27, 0x7b, 0xe2, 0x47, 0xaf, + 0x19, 0x5b, 0xf7, 0x4d, 0x9a, 0xac, 0x79, 0x9e, 0x7a, 0xcf, 0xc0, 0xb8, 0x5f, 0x9e, 0x46, 0xf8, + 0x18, 0xa3, 0x42, 0xec, 0x59, 0xf1, 0xa4, 0x9a, 0x92, 0x2f, 0xce, 0xc6, 0x36, 0xbf, 0x71, 0xac, + 0x3a, 0xb1, 0xfe, 0xca, 0xc2, 0xae, 0xa1, 0x61, 0x1e, 0xe8, 0x3e, 0x3b, 0x56, 0x46, 0x02, 0x20, + 0xe9, 0xe5, 0x17, 0x5e, 0x0a, 0x37, 0x75, 0xf9, 0x1b, 0xd7, 0xd1, 0xbf, 0x6c, 0x6e, 0xd5, 0xf7, + 0xf1, 0xf1, 0x34, 0x39, 0xeb, 0x35, 0x06, 0xeb, 0xa2, 0x59, 0x72, 0xff, 0x8e, 0xef, 0xcd, 0xec, + 0x89, 0xa6, 0x68, 0x88, 0xef, 0x60, 0x53, 0xf2, 0xe6, 0x4a, 0xeb, 0x9d, 0xda, 0x37, 0x6b, 0x9f, + 0xfa, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0xe1, 0x51, 0xdb, 0x9f, 0x62, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/client_server_2.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/client_server_2.pb.go new file mode 100644 index 00000000..5b4d36bc --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/client_server_2.pb.go @@ -0,0 +1,8018 @@ +// Code generated by protoc-gen-go. +// source: steammessages_clientserver_2.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CMsgClientUCMAddScreenshot struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Filename *string `protobuf:"bytes,2,opt,name=filename" json:"filename,omitempty"` + Thumbname *string `protobuf:"bytes,3,opt,name=thumbname" json:"thumbname,omitempty"` + Rtime32Created *uint32 `protobuf:"fixed32,4,opt,name=rtime32_created" json:"rtime32_created,omitempty"` + Width *uint32 `protobuf:"varint,5,opt,name=width" json:"width,omitempty"` + Height *uint32 `protobuf:"varint,6,opt,name=height" json:"height,omitempty"` + Permissions *uint32 `protobuf:"varint,7,opt,name=permissions" json:"permissions,omitempty"` + Caption *string `protobuf:"bytes,8,opt,name=caption" json:"caption,omitempty"` + ShortcutName *string `protobuf:"bytes,9,opt,name=shortcut_name" json:"shortcut_name,omitempty"` + Tag []*CMsgClientUCMAddScreenshot_Tag `protobuf:"bytes,10,rep,name=tag" json:"tag,omitempty"` + TaggedSteamid []uint64 `protobuf:"fixed64,11,rep,name=tagged_steamid" json:"tagged_steamid,omitempty"` + SpoilerTag *bool `protobuf:"varint,12,opt,name=spoiler_tag" json:"spoiler_tag,omitempty"` + TaggedPublishedfileid []uint64 `protobuf:"varint,13,rep,name=tagged_publishedfileid" json:"tagged_publishedfileid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMAddScreenshot) Reset() { *m = CMsgClientUCMAddScreenshot{} } +func (m *CMsgClientUCMAddScreenshot) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMAddScreenshot) ProtoMessage() {} +func (*CMsgClientUCMAddScreenshot) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{0} } + +func (m *CMsgClientUCMAddScreenshot) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientUCMAddScreenshot) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientUCMAddScreenshot) GetThumbname() string { + if m != nil && m.Thumbname != nil { + return *m.Thumbname + } + return "" +} + +func (m *CMsgClientUCMAddScreenshot) GetRtime32Created() uint32 { + if m != nil && m.Rtime32Created != nil { + return *m.Rtime32Created + } + return 0 +} + +func (m *CMsgClientUCMAddScreenshot) GetWidth() uint32 { + if m != nil && m.Width != nil { + return *m.Width + } + return 0 +} + +func (m *CMsgClientUCMAddScreenshot) GetHeight() uint32 { + if m != nil && m.Height != nil { + return *m.Height + } + return 0 +} + +func (m *CMsgClientUCMAddScreenshot) GetPermissions() uint32 { + if m != nil && m.Permissions != nil { + return *m.Permissions + } + return 0 +} + +func (m *CMsgClientUCMAddScreenshot) GetCaption() string { + if m != nil && m.Caption != nil { + return *m.Caption + } + return "" +} + +func (m *CMsgClientUCMAddScreenshot) GetShortcutName() string { + if m != nil && m.ShortcutName != nil { + return *m.ShortcutName + } + return "" +} + +func (m *CMsgClientUCMAddScreenshot) GetTag() []*CMsgClientUCMAddScreenshot_Tag { + if m != nil { + return m.Tag + } + return nil +} + +func (m *CMsgClientUCMAddScreenshot) GetTaggedSteamid() []uint64 { + if m != nil { + return m.TaggedSteamid + } + return nil +} + +func (m *CMsgClientUCMAddScreenshot) GetSpoilerTag() bool { + if m != nil && m.SpoilerTag != nil { + return *m.SpoilerTag + } + return false +} + +func (m *CMsgClientUCMAddScreenshot) GetTaggedPublishedfileid() []uint64 { + if m != nil { + return m.TaggedPublishedfileid + } + return nil +} + +type CMsgClientUCMAddScreenshot_Tag struct { + TagName *string `protobuf:"bytes,1,opt,name=tag_name" json:"tag_name,omitempty"` + TagValue *string `protobuf:"bytes,2,opt,name=tag_value" json:"tag_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMAddScreenshot_Tag) Reset() { *m = CMsgClientUCMAddScreenshot_Tag{} } +func (m *CMsgClientUCMAddScreenshot_Tag) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMAddScreenshot_Tag) ProtoMessage() {} +func (*CMsgClientUCMAddScreenshot_Tag) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{0, 0} +} + +func (m *CMsgClientUCMAddScreenshot_Tag) GetTagName() string { + if m != nil && m.TagName != nil { + return *m.TagName + } + return "" +} + +func (m *CMsgClientUCMAddScreenshot_Tag) GetTagValue() string { + if m != nil && m.TagValue != nil { + return *m.TagValue + } + return "" +} + +type CMsgClientUCMAddScreenshotResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Screenshotid *uint64 `protobuf:"fixed64,2,opt,name=screenshotid,def=18446744073709551615" json:"screenshotid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMAddScreenshotResponse) Reset() { *m = CMsgClientUCMAddScreenshotResponse{} } +func (m *CMsgClientUCMAddScreenshotResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMAddScreenshotResponse) ProtoMessage() {} +func (*CMsgClientUCMAddScreenshotResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{1} +} + +const Default_CMsgClientUCMAddScreenshotResponse_Eresult int32 = 2 +const Default_CMsgClientUCMAddScreenshotResponse_Screenshotid uint64 = 18446744073709551615 + +func (m *CMsgClientUCMAddScreenshotResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMAddScreenshotResponse_Eresult +} + +func (m *CMsgClientUCMAddScreenshotResponse) GetScreenshotid() uint64 { + if m != nil && m.Screenshotid != nil { + return *m.Screenshotid + } + return Default_CMsgClientUCMAddScreenshotResponse_Screenshotid +} + +type CMsgClientUCMDeleteScreenshot struct { + Screenshotid *uint64 `protobuf:"fixed64,1,opt,name=screenshotid,def=18446744073709551615" json:"screenshotid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMDeleteScreenshot) Reset() { *m = CMsgClientUCMDeleteScreenshot{} } +func (m *CMsgClientUCMDeleteScreenshot) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMDeleteScreenshot) ProtoMessage() {} +func (*CMsgClientUCMDeleteScreenshot) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{2} } + +const Default_CMsgClientUCMDeleteScreenshot_Screenshotid uint64 = 18446744073709551615 + +func (m *CMsgClientUCMDeleteScreenshot) GetScreenshotid() uint64 { + if m != nil && m.Screenshotid != nil { + return *m.Screenshotid + } + return Default_CMsgClientUCMDeleteScreenshot_Screenshotid +} + +type CMsgClientUCMDeleteScreenshotResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMDeleteScreenshotResponse) Reset() { *m = CMsgClientUCMDeleteScreenshotResponse{} } +func (m *CMsgClientUCMDeleteScreenshotResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMDeleteScreenshotResponse) ProtoMessage() {} +func (*CMsgClientUCMDeleteScreenshotResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{3} +} + +const Default_CMsgClientUCMDeleteScreenshotResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMDeleteScreenshotResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMDeleteScreenshotResponse_Eresult +} + +type CMsgClientUCMPublishFile struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + FileName *string `protobuf:"bytes,2,opt,name=file_name" json:"file_name,omitempty"` + PreviewFileName *string `protobuf:"bytes,3,opt,name=preview_file_name" json:"preview_file_name,omitempty"` + ConsumerAppId *uint32 `protobuf:"varint,4,opt,name=consumer_app_id" json:"consumer_app_id,omitempty"` + Title *string `protobuf:"bytes,5,opt,name=title" json:"title,omitempty"` + Description *string `protobuf:"bytes,6,opt,name=description" json:"description,omitempty"` + Tags []string `protobuf:"bytes,8,rep,name=tags" json:"tags,omitempty"` + WorkshopFile *bool `protobuf:"varint,9,opt,name=workshop_file" json:"workshop_file,omitempty"` + Visibility *int32 `protobuf:"varint,10,opt,name=visibility" json:"visibility,omitempty"` + FileType *uint32 `protobuf:"varint,11,opt,name=file_type" json:"file_type,omitempty"` + Url *string `protobuf:"bytes,12,opt,name=url" json:"url,omitempty"` + VideoProvider *uint32 `protobuf:"varint,13,opt,name=video_provider" json:"video_provider,omitempty"` + VideoAccountName *string `protobuf:"bytes,14,opt,name=video_account_name" json:"video_account_name,omitempty"` + VideoIdentifier *string `protobuf:"bytes,15,opt,name=video_identifier" json:"video_identifier,omitempty"` + InProgress *bool `protobuf:"varint,16,opt,name=in_progress" json:"in_progress,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMPublishFile) Reset() { *m = CMsgClientUCMPublishFile{} } +func (m *CMsgClientUCMPublishFile) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMPublishFile) ProtoMessage() {} +func (*CMsgClientUCMPublishFile) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{4} } + +func (m *CMsgClientUCMPublishFile) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMPublishFile) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +func (m *CMsgClientUCMPublishFile) GetPreviewFileName() string { + if m != nil && m.PreviewFileName != nil { + return *m.PreviewFileName + } + return "" +} + +func (m *CMsgClientUCMPublishFile) GetConsumerAppId() uint32 { + if m != nil && m.ConsumerAppId != nil { + return *m.ConsumerAppId + } + return 0 +} + +func (m *CMsgClientUCMPublishFile) GetTitle() string { + if m != nil && m.Title != nil { + return *m.Title + } + return "" +} + +func (m *CMsgClientUCMPublishFile) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CMsgClientUCMPublishFile) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *CMsgClientUCMPublishFile) GetWorkshopFile() bool { + if m != nil && m.WorkshopFile != nil { + return *m.WorkshopFile + } + return false +} + +func (m *CMsgClientUCMPublishFile) GetVisibility() int32 { + if m != nil && m.Visibility != nil { + return *m.Visibility + } + return 0 +} + +func (m *CMsgClientUCMPublishFile) GetFileType() uint32 { + if m != nil && m.FileType != nil { + return *m.FileType + } + return 0 +} + +func (m *CMsgClientUCMPublishFile) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CMsgClientUCMPublishFile) GetVideoProvider() uint32 { + if m != nil && m.VideoProvider != nil { + return *m.VideoProvider + } + return 0 +} + +func (m *CMsgClientUCMPublishFile) GetVideoAccountName() string { + if m != nil && m.VideoAccountName != nil { + return *m.VideoAccountName + } + return "" +} + +func (m *CMsgClientUCMPublishFile) GetVideoIdentifier() string { + if m != nil && m.VideoIdentifier != nil { + return *m.VideoIdentifier + } + return "" +} + +func (m *CMsgClientUCMPublishFile) GetInProgress() bool { + if m != nil && m.InProgress != nil { + return *m.InProgress + } + return false +} + +type CMsgClientUCMPublishFileResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PublishedFileId *uint64 `protobuf:"fixed64,2,opt,name=published_file_id,def=18446744073709551615" json:"published_file_id,omitempty"` + NeedsWorkshopLegalAgreementAcceptance *bool `protobuf:"varint,3,opt,name=needs_workshop_legal_agreement_acceptance,def=0" json:"needs_workshop_legal_agreement_acceptance,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMPublishFileResponse) Reset() { *m = CMsgClientUCMPublishFileResponse{} } +func (m *CMsgClientUCMPublishFileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMPublishFileResponse) ProtoMessage() {} +func (*CMsgClientUCMPublishFileResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{5} +} + +const Default_CMsgClientUCMPublishFileResponse_Eresult int32 = 2 +const Default_CMsgClientUCMPublishFileResponse_PublishedFileId uint64 = 18446744073709551615 +const Default_CMsgClientUCMPublishFileResponse_NeedsWorkshopLegalAgreementAcceptance bool = false + +func (m *CMsgClientUCMPublishFileResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMPublishFileResponse_Eresult +} + +func (m *CMsgClientUCMPublishFileResponse) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return Default_CMsgClientUCMPublishFileResponse_PublishedFileId +} + +func (m *CMsgClientUCMPublishFileResponse) GetNeedsWorkshopLegalAgreementAcceptance() bool { + if m != nil && m.NeedsWorkshopLegalAgreementAcceptance != nil { + return *m.NeedsWorkshopLegalAgreementAcceptance + } + return Default_CMsgClientUCMPublishFileResponse_NeedsWorkshopLegalAgreementAcceptance +} + +type CMsgClientUCMUpdatePublishedFile struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + PublishedFileId *uint64 `protobuf:"fixed64,2,opt,name=published_file_id" json:"published_file_id,omitempty"` + FileName *string `protobuf:"bytes,3,opt,name=file_name" json:"file_name,omitempty"` + PreviewFileName *string `protobuf:"bytes,4,opt,name=preview_file_name" json:"preview_file_name,omitempty"` + Title *string `protobuf:"bytes,5,opt,name=title" json:"title,omitempty"` + Description *string `protobuf:"bytes,6,opt,name=description" json:"description,omitempty"` + Tags []string `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"` + Visibility *int32 `protobuf:"varint,8,opt,name=visibility" json:"visibility,omitempty"` + UpdateFile *bool `protobuf:"varint,9,opt,name=update_file" json:"update_file,omitempty"` + UpdatePreviewFile *bool `protobuf:"varint,10,opt,name=update_preview_file" json:"update_preview_file,omitempty"` + UpdateTitle *bool `protobuf:"varint,11,opt,name=update_title" json:"update_title,omitempty"` + UpdateDescription *bool `protobuf:"varint,12,opt,name=update_description" json:"update_description,omitempty"` + UpdateTags *bool `protobuf:"varint,13,opt,name=update_tags" json:"update_tags,omitempty"` + UpdateVisibility *bool `protobuf:"varint,14,opt,name=update_visibility" json:"update_visibility,omitempty"` + ChangeDescription *string `protobuf:"bytes,15,opt,name=change_description" json:"change_description,omitempty"` + UpdateUrl *bool `protobuf:"varint,16,opt,name=update_url" json:"update_url,omitempty"` + Url *string `protobuf:"bytes,17,opt,name=url" json:"url,omitempty"` + UpdateContentManifest *bool `protobuf:"varint,18,opt,name=update_content_manifest" json:"update_content_manifest,omitempty"` + ContentManifest *uint64 `protobuf:"fixed64,19,opt,name=content_manifest" json:"content_manifest,omitempty"` + Metadata *string `protobuf:"bytes,20,opt,name=metadata" json:"metadata,omitempty"` + UpdateMetadata *bool `protobuf:"varint,21,opt,name=update_metadata" json:"update_metadata,omitempty"` + Language *int32 `protobuf:"varint,22,opt,name=language,def=0" json:"language,omitempty"` + RemovedKvtags []string `protobuf:"bytes,23,rep,name=removed_kvtags" json:"removed_kvtags,omitempty"` + Kvtags []*CMsgClientUCMUpdatePublishedFile_KeyValueTag `protobuf:"bytes,24,rep,name=kvtags" json:"kvtags,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMUpdatePublishedFile) Reset() { *m = CMsgClientUCMUpdatePublishedFile{} } +func (m *CMsgClientUCMUpdatePublishedFile) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMUpdatePublishedFile) ProtoMessage() {} +func (*CMsgClientUCMUpdatePublishedFile) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{6} +} + +const Default_CMsgClientUCMUpdatePublishedFile_Language int32 = 0 + +func (m *CMsgClientUCMUpdatePublishedFile) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetFileName() string { + if m != nil && m.FileName != nil { + return *m.FileName + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetPreviewFileName() string { + if m != nil && m.PreviewFileName != nil { + return *m.PreviewFileName + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetTitle() string { + if m != nil && m.Title != nil { + return *m.Title + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetDescription() string { + if m != nil && m.Description != nil { + return *m.Description + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetVisibility() int32 { + if m != nil && m.Visibility != nil { + return *m.Visibility + } + return 0 +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateFile() bool { + if m != nil && m.UpdateFile != nil { + return *m.UpdateFile + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdatePreviewFile() bool { + if m != nil && m.UpdatePreviewFile != nil { + return *m.UpdatePreviewFile + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateTitle() bool { + if m != nil && m.UpdateTitle != nil { + return *m.UpdateTitle + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateDescription() bool { + if m != nil && m.UpdateDescription != nil { + return *m.UpdateDescription + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateTags() bool { + if m != nil && m.UpdateTags != nil { + return *m.UpdateTags + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateVisibility() bool { + if m != nil && m.UpdateVisibility != nil { + return *m.UpdateVisibility + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetChangeDescription() string { + if m != nil && m.ChangeDescription != nil { + return *m.ChangeDescription + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateUrl() bool { + if m != nil && m.UpdateUrl != nil { + return *m.UpdateUrl + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateContentManifest() bool { + if m != nil && m.UpdateContentManifest != nil { + return *m.UpdateContentManifest + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetContentManifest() uint64 { + if m != nil && m.ContentManifest != nil { + return *m.ContentManifest + } + return 0 +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetMetadata() string { + if m != nil && m.Metadata != nil { + return *m.Metadata + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetUpdateMetadata() bool { + if m != nil && m.UpdateMetadata != nil { + return *m.UpdateMetadata + } + return false +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return Default_CMsgClientUCMUpdatePublishedFile_Language +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetRemovedKvtags() []string { + if m != nil { + return m.RemovedKvtags + } + return nil +} + +func (m *CMsgClientUCMUpdatePublishedFile) GetKvtags() []*CMsgClientUCMUpdatePublishedFile_KeyValueTag { + if m != nil { + return m.Kvtags + } + return nil +} + +type CMsgClientUCMUpdatePublishedFile_KeyValueTag struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMUpdatePublishedFile_KeyValueTag) Reset() { + *m = CMsgClientUCMUpdatePublishedFile_KeyValueTag{} +} +func (m *CMsgClientUCMUpdatePublishedFile_KeyValueTag) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMUpdatePublishedFile_KeyValueTag) ProtoMessage() {} +func (*CMsgClientUCMUpdatePublishedFile_KeyValueTag) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{6, 0} +} + +func (m *CMsgClientUCMUpdatePublishedFile_KeyValueTag) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *CMsgClientUCMUpdatePublishedFile_KeyValueTag) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CMsgClientUCMUpdatePublishedFileResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + NeedsWorkshopLegalAgreementAcceptance *bool `protobuf:"varint,2,opt,name=needs_workshop_legal_agreement_acceptance,def=0" json:"needs_workshop_legal_agreement_acceptance,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMUpdatePublishedFileResponse) Reset() { + *m = CMsgClientUCMUpdatePublishedFileResponse{} +} +func (m *CMsgClientUCMUpdatePublishedFileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMUpdatePublishedFileResponse) ProtoMessage() {} +func (*CMsgClientUCMUpdatePublishedFileResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{7} +} + +const Default_CMsgClientUCMUpdatePublishedFileResponse_Eresult int32 = 2 +const Default_CMsgClientUCMUpdatePublishedFileResponse_NeedsWorkshopLegalAgreementAcceptance bool = false + +func (m *CMsgClientUCMUpdatePublishedFileResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMUpdatePublishedFileResponse_Eresult +} + +func (m *CMsgClientUCMUpdatePublishedFileResponse) GetNeedsWorkshopLegalAgreementAcceptance() bool { + if m != nil && m.NeedsWorkshopLegalAgreementAcceptance != nil { + return *m.NeedsWorkshopLegalAgreementAcceptance + } + return Default_CMsgClientUCMUpdatePublishedFileResponse_NeedsWorkshopLegalAgreementAcceptance +} + +type CMsgClientUCMDeletePublishedFile struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMDeletePublishedFile) Reset() { *m = CMsgClientUCMDeletePublishedFile{} } +func (m *CMsgClientUCMDeletePublishedFile) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMDeletePublishedFile) ProtoMessage() {} +func (*CMsgClientUCMDeletePublishedFile) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{8} +} + +func (m *CMsgClientUCMDeletePublishedFile) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +type CMsgClientUCMDeletePublishedFileResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMDeletePublishedFileResponse) Reset() { + *m = CMsgClientUCMDeletePublishedFileResponse{} +} +func (m *CMsgClientUCMDeletePublishedFileResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMDeletePublishedFileResponse) ProtoMessage() {} +func (*CMsgClientUCMDeletePublishedFileResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{9} +} + +const Default_CMsgClientUCMDeletePublishedFileResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMDeletePublishedFileResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMDeletePublishedFileResponse_Eresult +} + +type CMsgClientUCMEnumerateUserPublishedFiles struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + StartIndex *uint32 `protobuf:"varint,2,opt,name=start_index" json:"start_index,omitempty"` + SortOrder *uint32 `protobuf:"varint,3,opt,name=sort_order" json:"sort_order,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserPublishedFiles) Reset() { + *m = CMsgClientUCMEnumerateUserPublishedFiles{} +} +func (m *CMsgClientUCMEnumerateUserPublishedFiles) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMEnumerateUserPublishedFiles) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserPublishedFiles) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{10} +} + +func (m *CMsgClientUCMEnumerateUserPublishedFiles) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserPublishedFiles) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserPublishedFiles) GetSortOrder() uint32 { + if m != nil && m.SortOrder != nil { + return *m.SortOrder + } + return 0 +} + +type CMsgClientUCMEnumerateUserPublishedFilesResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PublishedFiles []*CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId `protobuf:"bytes,2,rep,name=published_files" json:"published_files,omitempty"` + TotalResults *uint32 `protobuf:"varint,3,opt,name=total_results" json:"total_results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse) Reset() { + *m = CMsgClientUCMEnumerateUserPublishedFilesResponse{} +} +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumerateUserPublishedFilesResponse) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserPublishedFilesResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{11} +} + +const Default_CMsgClientUCMEnumerateUserPublishedFilesResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMEnumerateUserPublishedFilesResponse_Eresult +} + +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse) GetPublishedFiles() []*CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId { + if m != nil { + return m.PublishedFiles + } + return nil +} + +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse) GetTotalResults() uint32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +type CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId) Reset() { + *m = CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId{} +} +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{11, 0} +} + +func (m *CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +type CMsgClientUCMEnumerateUserSubscribedFiles struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + StartIndex *uint32 `protobuf:"varint,2,opt,name=start_index" json:"start_index,omitempty"` + ListType *uint32 `protobuf:"varint,3,opt,name=list_type,def=1" json:"list_type,omitempty"` + MatchingFileType *uint32 `protobuf:"varint,4,opt,name=matching_file_type,def=0" json:"matching_file_type,omitempty"` + Count *uint32 `protobuf:"varint,5,opt,name=count,def=50" json:"count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFiles) Reset() { + *m = CMsgClientUCMEnumerateUserSubscribedFiles{} +} +func (m *CMsgClientUCMEnumerateUserSubscribedFiles) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMEnumerateUserSubscribedFiles) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserSubscribedFiles) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{12} +} + +const Default_CMsgClientUCMEnumerateUserSubscribedFiles_ListType uint32 = 1 +const Default_CMsgClientUCMEnumerateUserSubscribedFiles_MatchingFileType uint32 = 0 +const Default_CMsgClientUCMEnumerateUserSubscribedFiles_Count uint32 = 50 + +func (m *CMsgClientUCMEnumerateUserSubscribedFiles) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFiles) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFiles) GetListType() uint32 { + if m != nil && m.ListType != nil { + return *m.ListType + } + return Default_CMsgClientUCMEnumerateUserSubscribedFiles_ListType +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFiles) GetMatchingFileType() uint32 { + if m != nil && m.MatchingFileType != nil { + return *m.MatchingFileType + } + return Default_CMsgClientUCMEnumerateUserSubscribedFiles_MatchingFileType +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFiles) GetCount() uint32 { + if m != nil && m.Count != nil { + return *m.Count + } + return Default_CMsgClientUCMEnumerateUserSubscribedFiles_Count +} + +type CMsgClientUCMEnumerateUserSubscribedFilesResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + SubscribedFiles []*CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId `protobuf:"bytes,2,rep,name=subscribed_files" json:"subscribed_files,omitempty"` + TotalResults *uint32 `protobuf:"varint,3,opt,name=total_results" json:"total_results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse) Reset() { + *m = CMsgClientUCMEnumerateUserSubscribedFilesResponse{} +} +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumerateUserSubscribedFilesResponse) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserSubscribedFilesResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{13} +} + +const Default_CMsgClientUCMEnumerateUserSubscribedFilesResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMEnumerateUserSubscribedFilesResponse_Eresult +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse) GetSubscribedFiles() []*CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId { + if m != nil { + return m.SubscribedFiles + } + return nil +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse) GetTotalResults() uint32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +type CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + Rtime32Subscribed *uint32 `protobuf:"fixed32,2,opt,name=rtime32_subscribed,def=0" json:"rtime32_subscribed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId) Reset() { + *m = CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId{} +} +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{13, 0} +} + +const Default_CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId_Rtime32Subscribed uint32 = 0 + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId) GetRtime32Subscribed() uint32 { + if m != nil && m.Rtime32Subscribed != nil { + return *m.Rtime32Subscribed + } + return Default_CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId_Rtime32Subscribed +} + +type CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + StartIndex *uint32 `protobuf:"varint,2,opt,name=start_index" json:"start_index,omitempty"` + StartTime *uint32 `protobuf:"fixed32,3,opt,name=start_time" json:"start_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates) Reset() { + *m = CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates{} +} +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{14} +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates) GetStartTime() uint32 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +type CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + SubscribedFiles []*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId `protobuf:"bytes,2,rep,name=subscribed_files" json:"subscribed_files,omitempty"` + TotalResults *uint32 `protobuf:"varint,3,opt,name=total_results" json:"total_results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse) Reset() { + *m = CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse{} +} +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{15} +} + +const Default_CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_Eresult +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse) GetSubscribedFiles() []*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId { + if m != nil { + return m.SubscribedFiles + } + return nil +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse) GetTotalResults() uint32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +type CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + Rtime32Subscribed *uint32 `protobuf:"fixed32,2,opt,name=rtime32_subscribed,def=0" json:"rtime32_subscribed,omitempty"` + Appid *uint32 `protobuf:"varint,3,opt,name=appid" json:"appid,omitempty"` + FileHcontent *uint64 `protobuf:"fixed64,4,opt,name=file_hcontent" json:"file_hcontent,omitempty"` + FileSize *uint32 `protobuf:"varint,5,opt,name=file_size" json:"file_size,omitempty"` + Rtime32LastUpdated *uint32 `protobuf:"fixed32,6,opt,name=rtime32_last_updated" json:"rtime32_last_updated,omitempty"` + IsDepotContent *bool `protobuf:"varint,7,opt,name=is_depot_content" json:"is_depot_content,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) Reset() { + *m = CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId{} +} +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) ProtoMessage() {} +func (*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{15, 0} +} + +const Default_CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId_Rtime32Subscribed uint32 = 0 + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) GetRtime32Subscribed() uint32 { + if m != nil && m.Rtime32Subscribed != nil { + return *m.Rtime32Subscribed + } + return Default_CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId_Rtime32Subscribed +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) GetFileHcontent() uint64 { + if m != nil && m.FileHcontent != nil { + return *m.FileHcontent + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) GetRtime32LastUpdated() uint32 { + if m != nil && m.Rtime32LastUpdated != nil { + return *m.Rtime32LastUpdated + } + return 0 +} + +func (m *CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId) GetIsDepotContent() bool { + if m != nil && m.IsDepotContent != nil { + return *m.IsDepotContent + } + return false +} + +type CMsgClientUCMPublishedFileSubscribed struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + FileHcontent *uint64 `protobuf:"fixed64,3,opt,name=file_hcontent" json:"file_hcontent,omitempty"` + FileSize *uint32 `protobuf:"varint,4,opt,name=file_size" json:"file_size,omitempty"` + RtimeSubscribed *uint32 `protobuf:"varint,5,opt,name=rtime_subscribed" json:"rtime_subscribed,omitempty"` + IsDepotContent *bool `protobuf:"varint,6,opt,name=is_depot_content" json:"is_depot_content,omitempty"` + RtimeUpdated *uint32 `protobuf:"varint,7,opt,name=rtime_updated" json:"rtime_updated,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMPublishedFileSubscribed) Reset() { *m = CMsgClientUCMPublishedFileSubscribed{} } +func (m *CMsgClientUCMPublishedFileSubscribed) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMPublishedFileSubscribed) ProtoMessage() {} +func (*CMsgClientUCMPublishedFileSubscribed) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{16} +} + +func (m *CMsgClientUCMPublishedFileSubscribed) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileSubscribed) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileSubscribed) GetFileHcontent() uint64 { + if m != nil && m.FileHcontent != nil { + return *m.FileHcontent + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileSubscribed) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileSubscribed) GetRtimeSubscribed() uint32 { + if m != nil && m.RtimeSubscribed != nil { + return *m.RtimeSubscribed + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileSubscribed) GetIsDepotContent() bool { + if m != nil && m.IsDepotContent != nil { + return *m.IsDepotContent + } + return false +} + +func (m *CMsgClientUCMPublishedFileSubscribed) GetRtimeUpdated() uint32 { + if m != nil && m.RtimeUpdated != nil { + return *m.RtimeUpdated + } + return 0 +} + +type CMsgClientUCMPublishedFileUnsubscribed struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMPublishedFileUnsubscribed) Reset() { + *m = CMsgClientUCMPublishedFileUnsubscribed{} +} +func (m *CMsgClientUCMPublishedFileUnsubscribed) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMPublishedFileUnsubscribed) ProtoMessage() {} +func (*CMsgClientUCMPublishedFileUnsubscribed) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{17} +} + +func (m *CMsgClientUCMPublishedFileUnsubscribed) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileUnsubscribed) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientUCMPublishedFileDeleted struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMPublishedFileDeleted) Reset() { *m = CMsgClientUCMPublishedFileDeleted{} } +func (m *CMsgClientUCMPublishedFileDeleted) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMPublishedFileDeleted) ProtoMessage() {} +func (*CMsgClientUCMPublishedFileDeleted) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{18} +} + +func (m *CMsgClientUCMPublishedFileDeleted) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileDeleted) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientUCMPublishedFileUpdated struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,3,opt,name=time_updated" json:"time_updated,omitempty"` + Hcontent *uint64 `protobuf:"fixed64,4,opt,name=hcontent" json:"hcontent,omitempty"` + FileSize *uint32 `protobuf:"fixed32,5,opt,name=file_size" json:"file_size,omitempty"` + IsDepotContent *bool `protobuf:"varint,6,opt,name=is_depot_content" json:"is_depot_content,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMPublishedFileUpdated) Reset() { *m = CMsgClientUCMPublishedFileUpdated{} } +func (m *CMsgClientUCMPublishedFileUpdated) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMPublishedFileUpdated) ProtoMessage() {} +func (*CMsgClientUCMPublishedFileUpdated) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{19} +} + +func (m *CMsgClientUCMPublishedFileUpdated) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileUpdated) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileUpdated) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileUpdated) GetHcontent() uint64 { + if m != nil && m.Hcontent != nil { + return *m.Hcontent + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileUpdated) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CMsgClientUCMPublishedFileUpdated) GetIsDepotContent() bool { + if m != nil && m.IsDepotContent != nil { + return *m.IsDepotContent + } + return false +} + +type CMsgClientWorkshopItemChangesRequest struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + LastTimeUpdated *uint32 `protobuf:"varint,2,opt,name=last_time_updated" json:"last_time_updated,omitempty"` + NumItemsNeeded *uint32 `protobuf:"varint,3,opt,name=num_items_needed" json:"num_items_needed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWorkshopItemChangesRequest) Reset() { *m = CMsgClientWorkshopItemChangesRequest{} } +func (m *CMsgClientWorkshopItemChangesRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientWorkshopItemChangesRequest) ProtoMessage() {} +func (*CMsgClientWorkshopItemChangesRequest) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{20} +} + +func (m *CMsgClientWorkshopItemChangesRequest) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientWorkshopItemChangesRequest) GetLastTimeUpdated() uint32 { + if m != nil && m.LastTimeUpdated != nil { + return *m.LastTimeUpdated + } + return 0 +} + +func (m *CMsgClientWorkshopItemChangesRequest) GetNumItemsNeeded() uint32 { + if m != nil && m.NumItemsNeeded != nil { + return *m.NumItemsNeeded + } + return 0 +} + +type CMsgClientWorkshopItemChangesResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + UpdateTime *uint32 `protobuf:"varint,2,opt,name=update_time" json:"update_time,omitempty"` + WorkshopItems []*CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo `protobuf:"bytes,5,rep,name=workshop_items" json:"workshop_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWorkshopItemChangesResponse) Reset() { *m = CMsgClientWorkshopItemChangesResponse{} } +func (m *CMsgClientWorkshopItemChangesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientWorkshopItemChangesResponse) ProtoMessage() {} +func (*CMsgClientWorkshopItemChangesResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{21} +} + +const Default_CMsgClientWorkshopItemChangesResponse_Eresult int32 = 2 + +func (m *CMsgClientWorkshopItemChangesResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientWorkshopItemChangesResponse_Eresult +} + +func (m *CMsgClientWorkshopItemChangesResponse) GetUpdateTime() uint32 { + if m != nil && m.UpdateTime != nil { + return *m.UpdateTime + } + return 0 +} + +func (m *CMsgClientWorkshopItemChangesResponse) GetWorkshopItems() []*CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo { + if m != nil { + return m.WorkshopItems + } + return nil +} + +type CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,2,opt,name=time_updated" json:"time_updated,omitempty"` + ManifestId *uint64 `protobuf:"fixed64,3,opt,name=manifest_id" json:"manifest_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo) Reset() { + *m = CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo{} +} +func (m *CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo) ProtoMessage() {} +func (*CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{21, 0} +} + +func (m *CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +func (m *CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo) GetManifestId() uint64 { + if m != nil && m.ManifestId != nil { + return *m.ManifestId + } + return 0 +} + +type CMsgClientWorkshopItemInfoRequest struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + LastTimeUpdated *uint32 `protobuf:"varint,2,opt,name=last_time_updated" json:"last_time_updated,omitempty"` + WorkshopItems []*CMsgClientWorkshopItemInfoRequest_WorkshopItem `protobuf:"bytes,3,rep,name=workshop_items" json:"workshop_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWorkshopItemInfoRequest) Reset() { *m = CMsgClientWorkshopItemInfoRequest{} } +func (m *CMsgClientWorkshopItemInfoRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientWorkshopItemInfoRequest) ProtoMessage() {} +func (*CMsgClientWorkshopItemInfoRequest) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{22} +} + +func (m *CMsgClientWorkshopItemInfoRequest) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientWorkshopItemInfoRequest) GetLastTimeUpdated() uint32 { + if m != nil && m.LastTimeUpdated != nil { + return *m.LastTimeUpdated + } + return 0 +} + +func (m *CMsgClientWorkshopItemInfoRequest) GetWorkshopItems() []*CMsgClientWorkshopItemInfoRequest_WorkshopItem { + if m != nil { + return m.WorkshopItems + } + return nil +} + +type CMsgClientWorkshopItemInfoRequest_WorkshopItem struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,2,opt,name=time_updated" json:"time_updated,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWorkshopItemInfoRequest_WorkshopItem) Reset() { + *m = CMsgClientWorkshopItemInfoRequest_WorkshopItem{} +} +func (m *CMsgClientWorkshopItemInfoRequest_WorkshopItem) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientWorkshopItemInfoRequest_WorkshopItem) ProtoMessage() {} +func (*CMsgClientWorkshopItemInfoRequest_WorkshopItem) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{22, 0} +} + +func (m *CMsgClientWorkshopItemInfoRequest_WorkshopItem) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientWorkshopItemInfoRequest_WorkshopItem) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +type CMsgClientWorkshopItemInfoResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + UpdateTime *uint32 `protobuf:"varint,2,opt,name=update_time" json:"update_time,omitempty"` + WorkshopItems []*CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo `protobuf:"bytes,3,rep,name=workshop_items" json:"workshop_items,omitempty"` + PrivateItems []uint64 `protobuf:"fixed64,4,rep,name=private_items" json:"private_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWorkshopItemInfoResponse) Reset() { *m = CMsgClientWorkshopItemInfoResponse{} } +func (m *CMsgClientWorkshopItemInfoResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientWorkshopItemInfoResponse) ProtoMessage() {} +func (*CMsgClientWorkshopItemInfoResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{23} +} + +const Default_CMsgClientWorkshopItemInfoResponse_Eresult int32 = 2 + +func (m *CMsgClientWorkshopItemInfoResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientWorkshopItemInfoResponse_Eresult +} + +func (m *CMsgClientWorkshopItemInfoResponse) GetUpdateTime() uint32 { + if m != nil && m.UpdateTime != nil { + return *m.UpdateTime + } + return 0 +} + +func (m *CMsgClientWorkshopItemInfoResponse) GetWorkshopItems() []*CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo { + if m != nil { + return m.WorkshopItems + } + return nil +} + +func (m *CMsgClientWorkshopItemInfoResponse) GetPrivateItems() []uint64 { + if m != nil { + return m.PrivateItems + } + return nil +} + +type CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,2,opt,name=time_updated" json:"time_updated,omitempty"` + ManifestId *uint64 `protobuf:"fixed64,3,opt,name=manifest_id" json:"manifest_id,omitempty"` + IsLegacy *bool `protobuf:"varint,4,opt,name=is_legacy" json:"is_legacy,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) Reset() { + *m = CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo{} +} +func (m *CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) ProtoMessage() {} +func (*CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{23, 0} +} + +func (m *CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +func (m *CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) GetManifestId() uint64 { + if m != nil && m.ManifestId != nil { + return *m.ManifestId + } + return 0 +} + +func (m *CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo) GetIsLegacy() bool { + if m != nil && m.IsLegacy != nil { + return *m.IsLegacy + } + return false +} + +type CMsgClientUCMGetPublishedFilesForUser struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + CreatorSteamId *uint64 `protobuf:"fixed64,2,opt,name=creator_steam_id" json:"creator_steam_id,omitempty"` + RequiredTags []string `protobuf:"bytes,3,rep,name=required_tags" json:"required_tags,omitempty"` + ExcludedTags []string `protobuf:"bytes,4,rep,name=excluded_tags" json:"excluded_tags,omitempty"` + StartIndex *uint32 `protobuf:"varint,5,opt,name=start_index" json:"start_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMGetPublishedFilesForUser) Reset() { *m = CMsgClientUCMGetPublishedFilesForUser{} } +func (m *CMsgClientUCMGetPublishedFilesForUser) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMGetPublishedFilesForUser) ProtoMessage() {} +func (*CMsgClientUCMGetPublishedFilesForUser) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{24} +} + +func (m *CMsgClientUCMGetPublishedFilesForUser) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMGetPublishedFilesForUser) GetCreatorSteamId() uint64 { + if m != nil && m.CreatorSteamId != nil { + return *m.CreatorSteamId + } + return 0 +} + +func (m *CMsgClientUCMGetPublishedFilesForUser) GetRequiredTags() []string { + if m != nil { + return m.RequiredTags + } + return nil +} + +func (m *CMsgClientUCMGetPublishedFilesForUser) GetExcludedTags() []string { + if m != nil { + return m.ExcludedTags + } + return nil +} + +func (m *CMsgClientUCMGetPublishedFilesForUser) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +type CMsgClientUCMGetPublishedFilesForUserResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PublishedFiles []*CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId `protobuf:"bytes,2,rep,name=published_files" json:"published_files,omitempty"` + TotalResults *uint32 `protobuf:"varint,3,opt,name=total_results" json:"total_results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMGetPublishedFilesForUserResponse) Reset() { + *m = CMsgClientUCMGetPublishedFilesForUserResponse{} +} +func (m *CMsgClientUCMGetPublishedFilesForUserResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMGetPublishedFilesForUserResponse) ProtoMessage() {} +func (*CMsgClientUCMGetPublishedFilesForUserResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{25} +} + +const Default_CMsgClientUCMGetPublishedFilesForUserResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMGetPublishedFilesForUserResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMGetPublishedFilesForUserResponse_Eresult +} + +func (m *CMsgClientUCMGetPublishedFilesForUserResponse) GetPublishedFiles() []*CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId { + if m != nil { + return m.PublishedFiles + } + return nil +} + +func (m *CMsgClientUCMGetPublishedFilesForUserResponse) GetTotalResults() uint32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +type CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId) Reset() { + *m = CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId{} +} +func (m *CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId) ProtoMessage() {} +func (*CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{25, 0} +} + +func (m *CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +type CMsgClientUCMSetUserPublishedFileAction struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + Action *int32 `protobuf:"varint,3,opt,name=action" json:"action,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMSetUserPublishedFileAction) Reset() { + *m = CMsgClientUCMSetUserPublishedFileAction{} +} +func (m *CMsgClientUCMSetUserPublishedFileAction) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUCMSetUserPublishedFileAction) ProtoMessage() {} +func (*CMsgClientUCMSetUserPublishedFileAction) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{26} +} + +func (m *CMsgClientUCMSetUserPublishedFileAction) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMSetUserPublishedFileAction) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMSetUserPublishedFileAction) GetAction() int32 { + if m != nil && m.Action != nil { + return *m.Action + } + return 0 +} + +type CMsgClientUCMSetUserPublishedFileActionResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMSetUserPublishedFileActionResponse) Reset() { + *m = CMsgClientUCMSetUserPublishedFileActionResponse{} +} +func (m *CMsgClientUCMSetUserPublishedFileActionResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMSetUserPublishedFileActionResponse) ProtoMessage() {} +func (*CMsgClientUCMSetUserPublishedFileActionResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{27} +} + +const Default_CMsgClientUCMSetUserPublishedFileActionResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMSetUserPublishedFileActionResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMSetUserPublishedFileActionResponse_Eresult +} + +type CMsgClientUCMEnumeratePublishedFilesByUserAction struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + StartIndex *uint32 `protobuf:"varint,2,opt,name=start_index" json:"start_index,omitempty"` + Action *int32 `protobuf:"varint,3,opt,name=action" json:"action,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserAction) Reset() { + *m = CMsgClientUCMEnumeratePublishedFilesByUserAction{} +} +func (m *CMsgClientUCMEnumeratePublishedFilesByUserAction) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumeratePublishedFilesByUserAction) ProtoMessage() {} +func (*CMsgClientUCMEnumeratePublishedFilesByUserAction) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{28} +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserAction) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserAction) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserAction) GetAction() int32 { + if m != nil && m.Action != nil { + return *m.Action + } + return 0 +} + +type CMsgClientUCMEnumeratePublishedFilesByUserActionResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PublishedFiles []*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId `protobuf:"bytes,2,rep,name=published_files" json:"published_files,omitempty"` + TotalResults *uint32 `protobuf:"varint,3,opt,name=total_results" json:"total_results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse) Reset() { + *m = CMsgClientUCMEnumeratePublishedFilesByUserActionResponse{} +} +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse) ProtoMessage() {} +func (*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{29} +} + +const Default_CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_Eresult int32 = 2 + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_Eresult +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse) GetPublishedFiles() []*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId { + if m != nil { + return m.PublishedFiles + } + return nil +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse) GetTotalResults() uint32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +type CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + RtimeTimeStamp *uint32 `protobuf:"fixed32,2,opt,name=rtime_time_stamp,def=0" json:"rtime_time_stamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId) Reset() { + *m = CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId{} +} +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId) ProtoMessage() {} +func (*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{29, 0} +} + +const Default_CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId_RtimeTimeStamp uint32 = 0 + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId) GetRtimeTimeStamp() uint32 { + if m != nil && m.RtimeTimeStamp != nil { + return *m.RtimeTimeStamp + } + return Default_CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId_RtimeTimeStamp +} + +type CMsgClientScreenshotsChanged struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientScreenshotsChanged) Reset() { *m = CMsgClientScreenshotsChanged{} } +func (m *CMsgClientScreenshotsChanged) String() string { return proto.CompactTextString(m) } +func (*CMsgClientScreenshotsChanged) ProtoMessage() {} +func (*CMsgClientScreenshotsChanged) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{30} } + +type CMsgClientUpdateUserGameInfo struct { + SteamidIdgs *uint64 `protobuf:"fixed64,1,opt,name=steamid_idgs" json:"steamid_idgs,omitempty"` + Gameid *uint64 `protobuf:"fixed64,2,opt,name=gameid" json:"gameid,omitempty"` + GameIp *uint32 `protobuf:"varint,3,opt,name=game_ip" json:"game_ip,omitempty"` + GamePort *uint32 `protobuf:"varint,4,opt,name=game_port" json:"game_port,omitempty"` + Token []byte `protobuf:"bytes,5,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUpdateUserGameInfo) Reset() { *m = CMsgClientUpdateUserGameInfo{} } +func (m *CMsgClientUpdateUserGameInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUpdateUserGameInfo) ProtoMessage() {} +func (*CMsgClientUpdateUserGameInfo) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{31} } + +func (m *CMsgClientUpdateUserGameInfo) GetSteamidIdgs() uint64 { + if m != nil && m.SteamidIdgs != nil { + return *m.SteamidIdgs + } + return 0 +} + +func (m *CMsgClientUpdateUserGameInfo) GetGameid() uint64 { + if m != nil && m.Gameid != nil { + return *m.Gameid + } + return 0 +} + +func (m *CMsgClientUpdateUserGameInfo) GetGameIp() uint32 { + if m != nil && m.GameIp != nil { + return *m.GameIp + } + return 0 +} + +func (m *CMsgClientUpdateUserGameInfo) GetGamePort() uint32 { + if m != nil && m.GamePort != nil { + return *m.GamePort + } + return 0 +} + +func (m *CMsgClientUpdateUserGameInfo) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +type CMsgClientRichPresenceUpload struct { + RichPresenceKv []byte `protobuf:"bytes,1,opt,name=rich_presence_kv" json:"rich_presence_kv,omitempty"` + SteamidBroadcast []uint64 `protobuf:"fixed64,2,rep,name=steamid_broadcast" json:"steamid_broadcast,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRichPresenceUpload) Reset() { *m = CMsgClientRichPresenceUpload{} } +func (m *CMsgClientRichPresenceUpload) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRichPresenceUpload) ProtoMessage() {} +func (*CMsgClientRichPresenceUpload) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{32} } + +func (m *CMsgClientRichPresenceUpload) GetRichPresenceKv() []byte { + if m != nil { + return m.RichPresenceKv + } + return nil +} + +func (m *CMsgClientRichPresenceUpload) GetSteamidBroadcast() []uint64 { + if m != nil { + return m.SteamidBroadcast + } + return nil +} + +type CMsgClientRichPresenceRequest struct { + SteamidRequest []uint64 `protobuf:"fixed64,1,rep,name=steamid_request" json:"steamid_request,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRichPresenceRequest) Reset() { *m = CMsgClientRichPresenceRequest{} } +func (m *CMsgClientRichPresenceRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRichPresenceRequest) ProtoMessage() {} +func (*CMsgClientRichPresenceRequest) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{33} } + +func (m *CMsgClientRichPresenceRequest) GetSteamidRequest() []uint64 { + if m != nil { + return m.SteamidRequest + } + return nil +} + +type CMsgClientRichPresenceInfo struct { + RichPresence []*CMsgClientRichPresenceInfo_RichPresence `protobuf:"bytes,1,rep,name=rich_presence" json:"rich_presence,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRichPresenceInfo) Reset() { *m = CMsgClientRichPresenceInfo{} } +func (m *CMsgClientRichPresenceInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRichPresenceInfo) ProtoMessage() {} +func (*CMsgClientRichPresenceInfo) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{34} } + +func (m *CMsgClientRichPresenceInfo) GetRichPresence() []*CMsgClientRichPresenceInfo_RichPresence { + if m != nil { + return m.RichPresence + } + return nil +} + +type CMsgClientRichPresenceInfo_RichPresence struct { + SteamidUser *uint64 `protobuf:"fixed64,1,opt,name=steamid_user" json:"steamid_user,omitempty"` + RichPresenceKv []byte `protobuf:"bytes,2,opt,name=rich_presence_kv" json:"rich_presence_kv,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRichPresenceInfo_RichPresence) Reset() { + *m = CMsgClientRichPresenceInfo_RichPresence{} +} +func (m *CMsgClientRichPresenceInfo_RichPresence) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRichPresenceInfo_RichPresence) ProtoMessage() {} +func (*CMsgClientRichPresenceInfo_RichPresence) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{34, 0} +} + +func (m *CMsgClientRichPresenceInfo_RichPresence) GetSteamidUser() uint64 { + if m != nil && m.SteamidUser != nil { + return *m.SteamidUser + } + return 0 +} + +func (m *CMsgClientRichPresenceInfo_RichPresence) GetRichPresenceKv() []byte { + if m != nil { + return m.RichPresenceKv + } + return nil +} + +type CMsgClientCheckFileSignature struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCheckFileSignature) Reset() { *m = CMsgClientCheckFileSignature{} } +func (m *CMsgClientCheckFileSignature) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCheckFileSignature) ProtoMessage() {} +func (*CMsgClientCheckFileSignature) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{35} } + +func (m *CMsgClientCheckFileSignature) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientCheckFileSignatureResponse struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + Pid *uint32 `protobuf:"varint,2,opt,name=pid" json:"pid,omitempty"` + Eresult *uint32 `protobuf:"varint,3,opt,name=eresult" json:"eresult,omitempty"` + Filename *string `protobuf:"bytes,4,opt,name=filename" json:"filename,omitempty"` + Esignatureresult *uint32 `protobuf:"varint,5,opt,name=esignatureresult" json:"esignatureresult,omitempty"` + ShaFile []byte `protobuf:"bytes,6,opt,name=sha_file" json:"sha_file,omitempty"` + Signatureheader []byte `protobuf:"bytes,7,opt,name=signatureheader" json:"signatureheader,omitempty"` + Filesize *uint32 `protobuf:"varint,8,opt,name=filesize" json:"filesize,omitempty"` + Getlasterror *uint32 `protobuf:"varint,9,opt,name=getlasterror" json:"getlasterror,omitempty"` + Evalvesignaturecheckdetail *uint32 `protobuf:"varint,10,opt,name=evalvesignaturecheckdetail" json:"evalvesignaturecheckdetail,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCheckFileSignatureResponse) Reset() { *m = CMsgClientCheckFileSignatureResponse{} } +func (m *CMsgClientCheckFileSignatureResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCheckFileSignatureResponse) ProtoMessage() {} +func (*CMsgClientCheckFileSignatureResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{36} +} + +func (m *CMsgClientCheckFileSignatureResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientCheckFileSignatureResponse) GetPid() uint32 { + if m != nil && m.Pid != nil { + return *m.Pid + } + return 0 +} + +func (m *CMsgClientCheckFileSignatureResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgClientCheckFileSignatureResponse) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientCheckFileSignatureResponse) GetEsignatureresult() uint32 { + if m != nil && m.Esignatureresult != nil { + return *m.Esignatureresult + } + return 0 +} + +func (m *CMsgClientCheckFileSignatureResponse) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientCheckFileSignatureResponse) GetSignatureheader() []byte { + if m != nil { + return m.Signatureheader + } + return nil +} + +func (m *CMsgClientCheckFileSignatureResponse) GetFilesize() uint32 { + if m != nil && m.Filesize != nil { + return *m.Filesize + } + return 0 +} + +func (m *CMsgClientCheckFileSignatureResponse) GetGetlasterror() uint32 { + if m != nil && m.Getlasterror != nil { + return *m.Getlasterror + } + return 0 +} + +func (m *CMsgClientCheckFileSignatureResponse) GetEvalvesignaturecheckdetail() uint32 { + if m != nil && m.Evalvesignaturecheckdetail != nil { + return *m.Evalvesignaturecheckdetail + } + return 0 +} + +type CMsgClientReadMachineAuth struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + Offset *uint32 `protobuf:"varint,2,opt,name=offset" json:"offset,omitempty"` + Cubtoread *uint32 `protobuf:"varint,3,opt,name=cubtoread" json:"cubtoread,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientReadMachineAuth) Reset() { *m = CMsgClientReadMachineAuth{} } +func (m *CMsgClientReadMachineAuth) String() string { return proto.CompactTextString(m) } +func (*CMsgClientReadMachineAuth) ProtoMessage() {} +func (*CMsgClientReadMachineAuth) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{37} } + +func (m *CMsgClientReadMachineAuth) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientReadMachineAuth) GetOffset() uint32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return 0 +} + +func (m *CMsgClientReadMachineAuth) GetCubtoread() uint32 { + if m != nil && m.Cubtoread != nil { + return *m.Cubtoread + } + return 0 +} + +type CMsgClientReadMachineAuthResponse struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult" json:"eresult,omitempty"` + Filesize *uint32 `protobuf:"varint,3,opt,name=filesize" json:"filesize,omitempty"` + ShaFile []byte `protobuf:"bytes,4,opt,name=sha_file" json:"sha_file,omitempty"` + Getlasterror *uint32 `protobuf:"varint,5,opt,name=getlasterror" json:"getlasterror,omitempty"` + Offset *uint32 `protobuf:"varint,6,opt,name=offset" json:"offset,omitempty"` + Cubread *uint32 `protobuf:"varint,7,opt,name=cubread" json:"cubread,omitempty"` + BytesRead []byte `protobuf:"bytes,8,opt,name=bytes_read" json:"bytes_read,omitempty"` + FilenameSentry *string `protobuf:"bytes,9,opt,name=filename_sentry" json:"filename_sentry,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientReadMachineAuthResponse) Reset() { *m = CMsgClientReadMachineAuthResponse{} } +func (m *CMsgClientReadMachineAuthResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientReadMachineAuthResponse) ProtoMessage() {} +func (*CMsgClientReadMachineAuthResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{38} +} + +func (m *CMsgClientReadMachineAuthResponse) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientReadMachineAuthResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgClientReadMachineAuthResponse) GetFilesize() uint32 { + if m != nil && m.Filesize != nil { + return *m.Filesize + } + return 0 +} + +func (m *CMsgClientReadMachineAuthResponse) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientReadMachineAuthResponse) GetGetlasterror() uint32 { + if m != nil && m.Getlasterror != nil { + return *m.Getlasterror + } + return 0 +} + +func (m *CMsgClientReadMachineAuthResponse) GetOffset() uint32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return 0 +} + +func (m *CMsgClientReadMachineAuthResponse) GetCubread() uint32 { + if m != nil && m.Cubread != nil { + return *m.Cubread + } + return 0 +} + +func (m *CMsgClientReadMachineAuthResponse) GetBytesRead() []byte { + if m != nil { + return m.BytesRead + } + return nil +} + +func (m *CMsgClientReadMachineAuthResponse) GetFilenameSentry() string { + if m != nil && m.FilenameSentry != nil { + return *m.FilenameSentry + } + return "" +} + +type CMsgClientUpdateMachineAuth struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + Offset *uint32 `protobuf:"varint,2,opt,name=offset" json:"offset,omitempty"` + Cubtowrite *uint32 `protobuf:"varint,3,opt,name=cubtowrite" json:"cubtowrite,omitempty"` + Bytes []byte `protobuf:"bytes,4,opt,name=bytes" json:"bytes,omitempty"` + OtpType *uint32 `protobuf:"varint,5,opt,name=otp_type" json:"otp_type,omitempty"` + OtpIdentifier *string `protobuf:"bytes,6,opt,name=otp_identifier" json:"otp_identifier,omitempty"` + OtpSharedsecret []byte `protobuf:"bytes,7,opt,name=otp_sharedsecret" json:"otp_sharedsecret,omitempty"` + OtpTimedrift *uint32 `protobuf:"varint,8,opt,name=otp_timedrift" json:"otp_timedrift,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUpdateMachineAuth) Reset() { *m = CMsgClientUpdateMachineAuth{} } +func (m *CMsgClientUpdateMachineAuth) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUpdateMachineAuth) ProtoMessage() {} +func (*CMsgClientUpdateMachineAuth) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{39} } + +func (m *CMsgClientUpdateMachineAuth) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientUpdateMachineAuth) GetOffset() uint32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuth) GetCubtowrite() uint32 { + if m != nil && m.Cubtowrite != nil { + return *m.Cubtowrite + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuth) GetBytes() []byte { + if m != nil { + return m.Bytes + } + return nil +} + +func (m *CMsgClientUpdateMachineAuth) GetOtpType() uint32 { + if m != nil && m.OtpType != nil { + return *m.OtpType + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuth) GetOtpIdentifier() string { + if m != nil && m.OtpIdentifier != nil { + return *m.OtpIdentifier + } + return "" +} + +func (m *CMsgClientUpdateMachineAuth) GetOtpSharedsecret() []byte { + if m != nil { + return m.OtpSharedsecret + } + return nil +} + +func (m *CMsgClientUpdateMachineAuth) GetOtpTimedrift() uint32 { + if m != nil && m.OtpTimedrift != nil { + return *m.OtpTimedrift + } + return 0 +} + +type CMsgClientUpdateMachineAuthResponse struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult" json:"eresult,omitempty"` + Filesize *uint32 `protobuf:"varint,3,opt,name=filesize" json:"filesize,omitempty"` + ShaFile []byte `protobuf:"bytes,4,opt,name=sha_file" json:"sha_file,omitempty"` + Getlasterror *uint32 `protobuf:"varint,5,opt,name=getlasterror" json:"getlasterror,omitempty"` + Offset *uint32 `protobuf:"varint,6,opt,name=offset" json:"offset,omitempty"` + Cubwrote *uint32 `protobuf:"varint,7,opt,name=cubwrote" json:"cubwrote,omitempty"` + OtpType *int32 `protobuf:"varint,8,opt,name=otp_type" json:"otp_type,omitempty"` + OtpValue *uint32 `protobuf:"varint,9,opt,name=otp_value" json:"otp_value,omitempty"` + OtpIdentifier *string `protobuf:"bytes,10,opt,name=otp_identifier" json:"otp_identifier,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUpdateMachineAuthResponse) Reset() { *m = CMsgClientUpdateMachineAuthResponse{} } +func (m *CMsgClientUpdateMachineAuthResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUpdateMachineAuthResponse) ProtoMessage() {} +func (*CMsgClientUpdateMachineAuthResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{40} +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetFilesize() uint32 { + if m != nil && m.Filesize != nil { + return *m.Filesize + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetGetlasterror() uint32 { + if m != nil && m.Getlasterror != nil { + return *m.Getlasterror + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetOffset() uint32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetCubwrote() uint32 { + if m != nil && m.Cubwrote != nil { + return *m.Cubwrote + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetOtpType() int32 { + if m != nil && m.OtpType != nil { + return *m.OtpType + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetOtpValue() uint32 { + if m != nil && m.OtpValue != nil { + return *m.OtpValue + } + return 0 +} + +func (m *CMsgClientUpdateMachineAuthResponse) GetOtpIdentifier() string { + if m != nil && m.OtpIdentifier != nil { + return *m.OtpIdentifier + } + return "" +} + +type CMsgClientRequestMachineAuth struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + EresultSentryfile *uint32 `protobuf:"varint,2,opt,name=eresult_sentryfile" json:"eresult_sentryfile,omitempty"` + Filesize *uint32 `protobuf:"varint,3,opt,name=filesize" json:"filesize,omitempty"` + ShaSentryfile []byte `protobuf:"bytes,4,opt,name=sha_sentryfile" json:"sha_sentryfile,omitempty"` + LockAccountAction *int32 `protobuf:"varint,6,opt,name=lock_account_action" json:"lock_account_action,omitempty"` + OtpType *uint32 `protobuf:"varint,7,opt,name=otp_type" json:"otp_type,omitempty"` + OtpIdentifier *string `protobuf:"bytes,8,opt,name=otp_identifier" json:"otp_identifier,omitempty"` + OtpSharedsecret []byte `protobuf:"bytes,9,opt,name=otp_sharedsecret" json:"otp_sharedsecret,omitempty"` + OtpValue *uint32 `protobuf:"varint,10,opt,name=otp_value" json:"otp_value,omitempty"` + MachineName *string `protobuf:"bytes,11,opt,name=machine_name" json:"machine_name,omitempty"` + MachineNameUserchosen *string `protobuf:"bytes,12,opt,name=machine_name_userchosen" json:"machine_name_userchosen,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestMachineAuth) Reset() { *m = CMsgClientRequestMachineAuth{} } +func (m *CMsgClientRequestMachineAuth) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestMachineAuth) ProtoMessage() {} +func (*CMsgClientRequestMachineAuth) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{41} } + +func (m *CMsgClientRequestMachineAuth) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CMsgClientRequestMachineAuth) GetEresultSentryfile() uint32 { + if m != nil && m.EresultSentryfile != nil { + return *m.EresultSentryfile + } + return 0 +} + +func (m *CMsgClientRequestMachineAuth) GetFilesize() uint32 { + if m != nil && m.Filesize != nil { + return *m.Filesize + } + return 0 +} + +func (m *CMsgClientRequestMachineAuth) GetShaSentryfile() []byte { + if m != nil { + return m.ShaSentryfile + } + return nil +} + +func (m *CMsgClientRequestMachineAuth) GetLockAccountAction() int32 { + if m != nil && m.LockAccountAction != nil { + return *m.LockAccountAction + } + return 0 +} + +func (m *CMsgClientRequestMachineAuth) GetOtpType() uint32 { + if m != nil && m.OtpType != nil { + return *m.OtpType + } + return 0 +} + +func (m *CMsgClientRequestMachineAuth) GetOtpIdentifier() string { + if m != nil && m.OtpIdentifier != nil { + return *m.OtpIdentifier + } + return "" +} + +func (m *CMsgClientRequestMachineAuth) GetOtpSharedsecret() []byte { + if m != nil { + return m.OtpSharedsecret + } + return nil +} + +func (m *CMsgClientRequestMachineAuth) GetOtpValue() uint32 { + if m != nil && m.OtpValue != nil { + return *m.OtpValue + } + return 0 +} + +func (m *CMsgClientRequestMachineAuth) GetMachineName() string { + if m != nil && m.MachineName != nil { + return *m.MachineName + } + return "" +} + +func (m *CMsgClientRequestMachineAuth) GetMachineNameUserchosen() string { + if m != nil && m.MachineNameUserchosen != nil { + return *m.MachineNameUserchosen + } + return "" +} + +type CMsgClientRequestMachineAuthResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestMachineAuthResponse) Reset() { *m = CMsgClientRequestMachineAuthResponse{} } +func (m *CMsgClientRequestMachineAuthResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestMachineAuthResponse) ProtoMessage() {} +func (*CMsgClientRequestMachineAuthResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{42} +} + +func (m *CMsgClientRequestMachineAuthResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgClientCreateFriendsGroup struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Groupname *string `protobuf:"bytes,2,opt,name=groupname" json:"groupname,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCreateFriendsGroup) Reset() { *m = CMsgClientCreateFriendsGroup{} } +func (m *CMsgClientCreateFriendsGroup) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCreateFriendsGroup) ProtoMessage() {} +func (*CMsgClientCreateFriendsGroup) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{43} } + +func (m *CMsgClientCreateFriendsGroup) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgClientCreateFriendsGroup) GetGroupname() string { + if m != nil && m.Groupname != nil { + return *m.Groupname + } + return "" +} + +type CMsgClientCreateFriendsGroupResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + Groupid *int32 `protobuf:"varint,2,opt,name=groupid" json:"groupid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCreateFriendsGroupResponse) Reset() { *m = CMsgClientCreateFriendsGroupResponse{} } +func (m *CMsgClientCreateFriendsGroupResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCreateFriendsGroupResponse) ProtoMessage() {} +func (*CMsgClientCreateFriendsGroupResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{44} +} + +func (m *CMsgClientCreateFriendsGroupResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgClientCreateFriendsGroupResponse) GetGroupid() int32 { + if m != nil && m.Groupid != nil { + return *m.Groupid + } + return 0 +} + +type CMsgClientDeleteFriendsGroup struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Groupid *int32 `protobuf:"varint,2,opt,name=groupid" json:"groupid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDeleteFriendsGroup) Reset() { *m = CMsgClientDeleteFriendsGroup{} } +func (m *CMsgClientDeleteFriendsGroup) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDeleteFriendsGroup) ProtoMessage() {} +func (*CMsgClientDeleteFriendsGroup) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{45} } + +func (m *CMsgClientDeleteFriendsGroup) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgClientDeleteFriendsGroup) GetGroupid() int32 { + if m != nil && m.Groupid != nil { + return *m.Groupid + } + return 0 +} + +type CMsgClientDeleteFriendsGroupResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDeleteFriendsGroupResponse) Reset() { *m = CMsgClientDeleteFriendsGroupResponse{} } +func (m *CMsgClientDeleteFriendsGroupResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDeleteFriendsGroupResponse) ProtoMessage() {} +func (*CMsgClientDeleteFriendsGroupResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{46} +} + +func (m *CMsgClientDeleteFriendsGroupResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgClientRenameFriendsGroup struct { + Groupid *int32 `protobuf:"varint,1,opt,name=groupid" json:"groupid,omitempty"` + Groupname *string `protobuf:"bytes,2,opt,name=groupname" json:"groupname,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRenameFriendsGroup) Reset() { *m = CMsgClientRenameFriendsGroup{} } +func (m *CMsgClientRenameFriendsGroup) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRenameFriendsGroup) ProtoMessage() {} +func (*CMsgClientRenameFriendsGroup) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{47} } + +func (m *CMsgClientRenameFriendsGroup) GetGroupid() int32 { + if m != nil && m.Groupid != nil { + return *m.Groupid + } + return 0 +} + +func (m *CMsgClientRenameFriendsGroup) GetGroupname() string { + if m != nil && m.Groupname != nil { + return *m.Groupname + } + return "" +} + +type CMsgClientRenameFriendsGroupResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRenameFriendsGroupResponse) Reset() { *m = CMsgClientRenameFriendsGroupResponse{} } +func (m *CMsgClientRenameFriendsGroupResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRenameFriendsGroupResponse) ProtoMessage() {} +func (*CMsgClientRenameFriendsGroupResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{48} +} + +func (m *CMsgClientRenameFriendsGroupResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgClientAddFriendToGroup struct { + Groupid *int32 `protobuf:"varint,1,opt,name=groupid" json:"groupid,omitempty"` + Steamiduser *uint64 `protobuf:"fixed64,2,opt,name=steamiduser" json:"steamiduser,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAddFriendToGroup) Reset() { *m = CMsgClientAddFriendToGroup{} } +func (m *CMsgClientAddFriendToGroup) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAddFriendToGroup) ProtoMessage() {} +func (*CMsgClientAddFriendToGroup) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{49} } + +func (m *CMsgClientAddFriendToGroup) GetGroupid() int32 { + if m != nil && m.Groupid != nil { + return *m.Groupid + } + return 0 +} + +func (m *CMsgClientAddFriendToGroup) GetSteamiduser() uint64 { + if m != nil && m.Steamiduser != nil { + return *m.Steamiduser + } + return 0 +} + +type CMsgClientAddFriendToGroupResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAddFriendToGroupResponse) Reset() { *m = CMsgClientAddFriendToGroupResponse{} } +func (m *CMsgClientAddFriendToGroupResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAddFriendToGroupResponse) ProtoMessage() {} +func (*CMsgClientAddFriendToGroupResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{50} +} + +func (m *CMsgClientAddFriendToGroupResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgClientRemoveFriendFromGroup struct { + Groupid *int32 `protobuf:"varint,1,opt,name=groupid" json:"groupid,omitempty"` + Steamiduser *uint64 `protobuf:"fixed64,2,opt,name=steamiduser" json:"steamiduser,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRemoveFriendFromGroup) Reset() { *m = CMsgClientRemoveFriendFromGroup{} } +func (m *CMsgClientRemoveFriendFromGroup) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRemoveFriendFromGroup) ProtoMessage() {} +func (*CMsgClientRemoveFriendFromGroup) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{51} +} + +func (m *CMsgClientRemoveFriendFromGroup) GetGroupid() int32 { + if m != nil && m.Groupid != nil { + return *m.Groupid + } + return 0 +} + +func (m *CMsgClientRemoveFriendFromGroup) GetSteamiduser() uint64 { + if m != nil && m.Steamiduser != nil { + return *m.Steamiduser + } + return 0 +} + +type CMsgClientRemoveFriendFromGroupResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRemoveFriendFromGroupResponse) Reset() { + *m = CMsgClientRemoveFriendFromGroupResponse{} +} +func (m *CMsgClientRemoveFriendFromGroupResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRemoveFriendFromGroupResponse) ProtoMessage() {} +func (*CMsgClientRemoveFriendFromGroupResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{52} +} + +func (m *CMsgClientRemoveFriendFromGroupResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgClientRegisterKey struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRegisterKey) Reset() { *m = CMsgClientRegisterKey{} } +func (m *CMsgClientRegisterKey) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRegisterKey) ProtoMessage() {} +func (*CMsgClientRegisterKey) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{53} } + +func (m *CMsgClientRegisterKey) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +type CMsgClientPurchaseResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PurchaseResultDetails *int32 `protobuf:"varint,2,opt,name=purchase_result_details" json:"purchase_result_details,omitempty"` + PurchaseReceiptInfo []byte `protobuf:"bytes,3,opt,name=purchase_receipt_info" json:"purchase_receipt_info,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPurchaseResponse) Reset() { *m = CMsgClientPurchaseResponse{} } +func (m *CMsgClientPurchaseResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPurchaseResponse) ProtoMessage() {} +func (*CMsgClientPurchaseResponse) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{54} } + +const Default_CMsgClientPurchaseResponse_Eresult int32 = 2 + +func (m *CMsgClientPurchaseResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientPurchaseResponse_Eresult +} + +func (m *CMsgClientPurchaseResponse) GetPurchaseResultDetails() int32 { + if m != nil && m.PurchaseResultDetails != nil { + return *m.PurchaseResultDetails + } + return 0 +} + +func (m *CMsgClientPurchaseResponse) GetPurchaseReceiptInfo() []byte { + if m != nil { + return m.PurchaseReceiptInfo + } + return nil +} + +type CMsgClientActivateOEMLicense struct { + BiosManufacturer *string `protobuf:"bytes,1,opt,name=bios_manufacturer" json:"bios_manufacturer,omitempty"` + BiosSerialnumber *string `protobuf:"bytes,2,opt,name=bios_serialnumber" json:"bios_serialnumber,omitempty"` + LicenseFile []byte `protobuf:"bytes,3,opt,name=license_file" json:"license_file,omitempty"` + MainboardManufacturer *string `protobuf:"bytes,4,opt,name=mainboard_manufacturer" json:"mainboard_manufacturer,omitempty"` + MainboardProduct *string `protobuf:"bytes,5,opt,name=mainboard_product" json:"mainboard_product,omitempty"` + MainboardSerialnumber *string `protobuf:"bytes,6,opt,name=mainboard_serialnumber" json:"mainboard_serialnumber,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientActivateOEMLicense) Reset() { *m = CMsgClientActivateOEMLicense{} } +func (m *CMsgClientActivateOEMLicense) String() string { return proto.CompactTextString(m) } +func (*CMsgClientActivateOEMLicense) ProtoMessage() {} +func (*CMsgClientActivateOEMLicense) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{55} } + +func (m *CMsgClientActivateOEMLicense) GetBiosManufacturer() string { + if m != nil && m.BiosManufacturer != nil { + return *m.BiosManufacturer + } + return "" +} + +func (m *CMsgClientActivateOEMLicense) GetBiosSerialnumber() string { + if m != nil && m.BiosSerialnumber != nil { + return *m.BiosSerialnumber + } + return "" +} + +func (m *CMsgClientActivateOEMLicense) GetLicenseFile() []byte { + if m != nil { + return m.LicenseFile + } + return nil +} + +func (m *CMsgClientActivateOEMLicense) GetMainboardManufacturer() string { + if m != nil && m.MainboardManufacturer != nil { + return *m.MainboardManufacturer + } + return "" +} + +func (m *CMsgClientActivateOEMLicense) GetMainboardProduct() string { + if m != nil && m.MainboardProduct != nil { + return *m.MainboardProduct + } + return "" +} + +func (m *CMsgClientActivateOEMLicense) GetMainboardSerialnumber() string { + if m != nil && m.MainboardSerialnumber != nil { + return *m.MainboardSerialnumber + } + return "" +} + +type CMsgClientRegisterOEMMachine struct { + OemRegisterFile []byte `protobuf:"bytes,1,opt,name=oem_register_file" json:"oem_register_file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRegisterOEMMachine) Reset() { *m = CMsgClientRegisterOEMMachine{} } +func (m *CMsgClientRegisterOEMMachine) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRegisterOEMMachine) ProtoMessage() {} +func (*CMsgClientRegisterOEMMachine) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{56} } + +func (m *CMsgClientRegisterOEMMachine) GetOemRegisterFile() []byte { + if m != nil { + return m.OemRegisterFile + } + return nil +} + +type CMsgClientRegisterOEMMachineResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRegisterOEMMachineResponse) Reset() { *m = CMsgClientRegisterOEMMachineResponse{} } +func (m *CMsgClientRegisterOEMMachineResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRegisterOEMMachineResponse) ProtoMessage() {} +func (*CMsgClientRegisterOEMMachineResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{57} +} + +func (m *CMsgClientRegisterOEMMachineResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +type CMsgClientPurchaseWithMachineID struct { + PackageId *uint32 `protobuf:"varint,1,opt,name=package_id" json:"package_id,omitempty"` + MachineInfo []byte `protobuf:"bytes,2,opt,name=machine_info" json:"machine_info,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPurchaseWithMachineID) Reset() { *m = CMsgClientPurchaseWithMachineID{} } +func (m *CMsgClientPurchaseWithMachineID) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPurchaseWithMachineID) ProtoMessage() {} +func (*CMsgClientPurchaseWithMachineID) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{58} +} + +func (m *CMsgClientPurchaseWithMachineID) GetPackageId() uint32 { + if m != nil && m.PackageId != nil { + return *m.PackageId + } + return 0 +} + +func (m *CMsgClientPurchaseWithMachineID) GetMachineInfo() []byte { + if m != nil { + return m.MachineInfo + } + return nil +} + +type CMsgTrading_InitiateTradeRequest struct { + TradeRequestId *uint32 `protobuf:"varint,1,opt,name=trade_request_id" json:"trade_request_id,omitempty"` + OtherSteamid *uint64 `protobuf:"varint,2,opt,name=other_steamid" json:"other_steamid,omitempty"` + OtherName *string `protobuf:"bytes,3,opt,name=other_name" json:"other_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgTrading_InitiateTradeRequest) Reset() { *m = CMsgTrading_InitiateTradeRequest{} } +func (m *CMsgTrading_InitiateTradeRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgTrading_InitiateTradeRequest) ProtoMessage() {} +func (*CMsgTrading_InitiateTradeRequest) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{59} +} + +func (m *CMsgTrading_InitiateTradeRequest) GetTradeRequestId() uint32 { + if m != nil && m.TradeRequestId != nil { + return *m.TradeRequestId + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeRequest) GetOtherSteamid() uint64 { + if m != nil && m.OtherSteamid != nil { + return *m.OtherSteamid + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeRequest) GetOtherName() string { + if m != nil && m.OtherName != nil { + return *m.OtherName + } + return "" +} + +type CMsgTrading_InitiateTradeResponse struct { + Response *uint32 `protobuf:"varint,1,opt,name=response" json:"response,omitempty"` + TradeRequestId *uint32 `protobuf:"varint,2,opt,name=trade_request_id" json:"trade_request_id,omitempty"` + OtherSteamid *uint64 `protobuf:"varint,3,opt,name=other_steamid" json:"other_steamid,omitempty"` + SteamguardRequiredDays *uint32 `protobuf:"varint,4,opt,name=steamguard_required_days" json:"steamguard_required_days,omitempty"` + NewDeviceCooldownDays *uint32 `protobuf:"varint,5,opt,name=new_device_cooldown_days" json:"new_device_cooldown_days,omitempty"` + DefaultPasswordResetProbationDays *uint32 `protobuf:"varint,6,opt,name=default_password_reset_probation_days" json:"default_password_reset_probation_days,omitempty"` + PasswordResetProbationDays *uint32 `protobuf:"varint,7,opt,name=password_reset_probation_days" json:"password_reset_probation_days,omitempty"` + DefaultEmailChangeProbationDays *uint32 `protobuf:"varint,8,opt,name=default_email_change_probation_days" json:"default_email_change_probation_days,omitempty"` + EmailChangeProbationDays *uint32 `protobuf:"varint,9,opt,name=email_change_probation_days" json:"email_change_probation_days,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgTrading_InitiateTradeResponse) Reset() { *m = CMsgTrading_InitiateTradeResponse{} } +func (m *CMsgTrading_InitiateTradeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgTrading_InitiateTradeResponse) ProtoMessage() {} +func (*CMsgTrading_InitiateTradeResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{60} +} + +func (m *CMsgTrading_InitiateTradeResponse) GetResponse() uint32 { + if m != nil && m.Response != nil { + return *m.Response + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetTradeRequestId() uint32 { + if m != nil && m.TradeRequestId != nil { + return *m.TradeRequestId + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetOtherSteamid() uint64 { + if m != nil && m.OtherSteamid != nil { + return *m.OtherSteamid + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetSteamguardRequiredDays() uint32 { + if m != nil && m.SteamguardRequiredDays != nil { + return *m.SteamguardRequiredDays + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetNewDeviceCooldownDays() uint32 { + if m != nil && m.NewDeviceCooldownDays != nil { + return *m.NewDeviceCooldownDays + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetDefaultPasswordResetProbationDays() uint32 { + if m != nil && m.DefaultPasswordResetProbationDays != nil { + return *m.DefaultPasswordResetProbationDays + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetPasswordResetProbationDays() uint32 { + if m != nil && m.PasswordResetProbationDays != nil { + return *m.PasswordResetProbationDays + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetDefaultEmailChangeProbationDays() uint32 { + if m != nil && m.DefaultEmailChangeProbationDays != nil { + return *m.DefaultEmailChangeProbationDays + } + return 0 +} + +func (m *CMsgTrading_InitiateTradeResponse) GetEmailChangeProbationDays() uint32 { + if m != nil && m.EmailChangeProbationDays != nil { + return *m.EmailChangeProbationDays + } + return 0 +} + +type CMsgTrading_CancelTradeRequest struct { + OtherSteamid *uint64 `protobuf:"varint,1,opt,name=other_steamid" json:"other_steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgTrading_CancelTradeRequest) Reset() { *m = CMsgTrading_CancelTradeRequest{} } +func (m *CMsgTrading_CancelTradeRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgTrading_CancelTradeRequest) ProtoMessage() {} +func (*CMsgTrading_CancelTradeRequest) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{61} } + +func (m *CMsgTrading_CancelTradeRequest) GetOtherSteamid() uint64 { + if m != nil && m.OtherSteamid != nil { + return *m.OtherSteamid + } + return 0 +} + +type CMsgTrading_StartSession struct { + OtherSteamid *uint64 `protobuf:"varint,1,opt,name=other_steamid" json:"other_steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgTrading_StartSession) Reset() { *m = CMsgTrading_StartSession{} } +func (m *CMsgTrading_StartSession) String() string { return proto.CompactTextString(m) } +func (*CMsgTrading_StartSession) ProtoMessage() {} +func (*CMsgTrading_StartSession) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{62} } + +func (m *CMsgTrading_StartSession) GetOtherSteamid() uint64 { + if m != nil && m.OtherSteamid != nil { + return *m.OtherSteamid + } + return 0 +} + +type CMsgClientEmailChange struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + Email *string `protobuf:"bytes,2,opt,name=email" json:"email,omitempty"` + Code *string `protobuf:"bytes,3,opt,name=code" json:"code,omitempty"` + Final *bool `protobuf:"varint,4,opt,name=final" json:"final,omitempty"` + Newmethod *bool `protobuf:"varint,5,opt,name=newmethod" json:"newmethod,omitempty"` + TwofactorCode *string `protobuf:"bytes,6,opt,name=twofactor_code" json:"twofactor_code,omitempty"` + SmsCode *string `protobuf:"bytes,7,opt,name=sms_code" json:"sms_code,omitempty"` + ClientSupportsSms *bool `protobuf:"varint,8,opt,name=client_supports_sms" json:"client_supports_sms,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientEmailChange) Reset() { *m = CMsgClientEmailChange{} } +func (m *CMsgClientEmailChange) String() string { return proto.CompactTextString(m) } +func (*CMsgClientEmailChange) ProtoMessage() {} +func (*CMsgClientEmailChange) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{63} } + +func (m *CMsgClientEmailChange) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CMsgClientEmailChange) GetEmail() string { + if m != nil && m.Email != nil { + return *m.Email + } + return "" +} + +func (m *CMsgClientEmailChange) GetCode() string { + if m != nil && m.Code != nil { + return *m.Code + } + return "" +} + +func (m *CMsgClientEmailChange) GetFinal() bool { + if m != nil && m.Final != nil { + return *m.Final + } + return false +} + +func (m *CMsgClientEmailChange) GetNewmethod() bool { + if m != nil && m.Newmethod != nil { + return *m.Newmethod + } + return false +} + +func (m *CMsgClientEmailChange) GetTwofactorCode() string { + if m != nil && m.TwofactorCode != nil { + return *m.TwofactorCode + } + return "" +} + +func (m *CMsgClientEmailChange) GetSmsCode() string { + if m != nil && m.SmsCode != nil { + return *m.SmsCode + } + return "" +} + +func (m *CMsgClientEmailChange) GetClientSupportsSms() bool { + if m != nil && m.ClientSupportsSms != nil { + return *m.ClientSupportsSms + } + return false +} + +type CMsgClientEmailChangeResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + RequiresSmsCode *bool `protobuf:"varint,2,opt,name=requires_sms_code" json:"requires_sms_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientEmailChangeResponse) Reset() { *m = CMsgClientEmailChangeResponse{} } +func (m *CMsgClientEmailChangeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientEmailChangeResponse) ProtoMessage() {} +func (*CMsgClientEmailChangeResponse) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{64} } + +const Default_CMsgClientEmailChangeResponse_Eresult int32 = 2 + +func (m *CMsgClientEmailChangeResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientEmailChangeResponse_Eresult +} + +func (m *CMsgClientEmailChangeResponse) GetRequiresSmsCode() bool { + if m != nil && m.RequiresSmsCode != nil { + return *m.RequiresSmsCode + } + return false +} + +type CMsgClientGetCDNAuthToken struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + HostName *string `protobuf:"bytes,2,opt,name=host_name" json:"host_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetCDNAuthToken) Reset() { *m = CMsgClientGetCDNAuthToken{} } +func (m *CMsgClientGetCDNAuthToken) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetCDNAuthToken) ProtoMessage() {} +func (*CMsgClientGetCDNAuthToken) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{65} } + +func (m *CMsgClientGetCDNAuthToken) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientGetCDNAuthToken) GetHostName() string { + if m != nil && m.HostName != nil { + return *m.HostName + } + return "" +} + +type CMsgClientGetDepotDecryptionKey struct { + DepotId *uint32 `protobuf:"varint,1,opt,name=depot_id" json:"depot_id,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetDepotDecryptionKey) Reset() { *m = CMsgClientGetDepotDecryptionKey{} } +func (m *CMsgClientGetDepotDecryptionKey) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetDepotDecryptionKey) ProtoMessage() {} +func (*CMsgClientGetDepotDecryptionKey) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{66} +} + +func (m *CMsgClientGetDepotDecryptionKey) GetDepotId() uint32 { + if m != nil && m.DepotId != nil { + return *m.DepotId + } + return 0 +} + +func (m *CMsgClientGetDepotDecryptionKey) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientGetDepotDecryptionKeyResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + DepotId *uint32 `protobuf:"varint,2,opt,name=depot_id" json:"depot_id,omitempty"` + DepotEncryptionKey []byte `protobuf:"bytes,3,opt,name=depot_encryption_key" json:"depot_encryption_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetDepotDecryptionKeyResponse) Reset() { + *m = CMsgClientGetDepotDecryptionKeyResponse{} +} +func (m *CMsgClientGetDepotDecryptionKeyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetDepotDecryptionKeyResponse) ProtoMessage() {} +func (*CMsgClientGetDepotDecryptionKeyResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{67} +} + +const Default_CMsgClientGetDepotDecryptionKeyResponse_Eresult int32 = 2 + +func (m *CMsgClientGetDepotDecryptionKeyResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientGetDepotDecryptionKeyResponse_Eresult +} + +func (m *CMsgClientGetDepotDecryptionKeyResponse) GetDepotId() uint32 { + if m != nil && m.DepotId != nil { + return *m.DepotId + } + return 0 +} + +func (m *CMsgClientGetDepotDecryptionKeyResponse) GetDepotEncryptionKey() []byte { + if m != nil { + return m.DepotEncryptionKey + } + return nil +} + +type CMsgClientGetAppBetaPasswords struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAppBetaPasswords) Reset() { *m = CMsgClientGetAppBetaPasswords{} } +func (m *CMsgClientGetAppBetaPasswords) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetAppBetaPasswords) ProtoMessage() {} +func (*CMsgClientGetAppBetaPasswords) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{68} } + +func (m *CMsgClientGetAppBetaPasswords) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CMsgClientGetAppBetaPasswordsResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + Betapasswords []*CMsgClientGetAppBetaPasswordsResponse_BetaPassword `protobuf:"bytes,3,rep,name=betapasswords" json:"betapasswords,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAppBetaPasswordsResponse) Reset() { *m = CMsgClientGetAppBetaPasswordsResponse{} } +func (m *CMsgClientGetAppBetaPasswordsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetAppBetaPasswordsResponse) ProtoMessage() {} +func (*CMsgClientGetAppBetaPasswordsResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{69} +} + +const Default_CMsgClientGetAppBetaPasswordsResponse_Eresult int32 = 2 + +func (m *CMsgClientGetAppBetaPasswordsResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientGetAppBetaPasswordsResponse_Eresult +} + +func (m *CMsgClientGetAppBetaPasswordsResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientGetAppBetaPasswordsResponse) GetBetapasswords() []*CMsgClientGetAppBetaPasswordsResponse_BetaPassword { + if m != nil { + return m.Betapasswords + } + return nil +} + +type CMsgClientGetAppBetaPasswordsResponse_BetaPassword struct { + Betaname *string `protobuf:"bytes,1,opt,name=betaname" json:"betaname,omitempty"` + Betapassword *string `protobuf:"bytes,2,opt,name=betapassword" json:"betapassword,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAppBetaPasswordsResponse_BetaPassword) Reset() { + *m = CMsgClientGetAppBetaPasswordsResponse_BetaPassword{} +} +func (m *CMsgClientGetAppBetaPasswordsResponse_BetaPassword) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientGetAppBetaPasswordsResponse_BetaPassword) ProtoMessage() {} +func (*CMsgClientGetAppBetaPasswordsResponse_BetaPassword) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{69, 0} +} + +func (m *CMsgClientGetAppBetaPasswordsResponse_BetaPassword) GetBetaname() string { + if m != nil && m.Betaname != nil { + return *m.Betaname + } + return "" +} + +func (m *CMsgClientGetAppBetaPasswordsResponse_BetaPassword) GetBetapassword() string { + if m != nil && m.Betapassword != nil { + return *m.Betapassword + } + return "" +} + +type CMsgClientCheckAppBetaPassword struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + Betapassword *string `protobuf:"bytes,2,opt,name=betapassword" json:"betapassword,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCheckAppBetaPassword) Reset() { *m = CMsgClientCheckAppBetaPassword{} } +func (m *CMsgClientCheckAppBetaPassword) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCheckAppBetaPassword) ProtoMessage() {} +func (*CMsgClientCheckAppBetaPassword) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{70} } + +func (m *CMsgClientCheckAppBetaPassword) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientCheckAppBetaPassword) GetBetapassword() string { + if m != nil && m.Betapassword != nil { + return *m.Betapassword + } + return "" +} + +type CMsgClientCheckAppBetaPasswordResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Betapasswords []*CMsgClientCheckAppBetaPasswordResponse_BetaPassword `protobuf:"bytes,4,rep,name=betapasswords" json:"betapasswords,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCheckAppBetaPasswordResponse) Reset() { + *m = CMsgClientCheckAppBetaPasswordResponse{} +} +func (m *CMsgClientCheckAppBetaPasswordResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCheckAppBetaPasswordResponse) ProtoMessage() {} +func (*CMsgClientCheckAppBetaPasswordResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{71} +} + +const Default_CMsgClientCheckAppBetaPasswordResponse_Eresult int32 = 2 + +func (m *CMsgClientCheckAppBetaPasswordResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientCheckAppBetaPasswordResponse_Eresult +} + +func (m *CMsgClientCheckAppBetaPasswordResponse) GetBetapasswords() []*CMsgClientCheckAppBetaPasswordResponse_BetaPassword { + if m != nil { + return m.Betapasswords + } + return nil +} + +type CMsgClientCheckAppBetaPasswordResponse_BetaPassword struct { + Betaname *string `protobuf:"bytes,1,opt,name=betaname" json:"betaname,omitempty"` + Betapassword *string `protobuf:"bytes,2,opt,name=betapassword" json:"betapassword,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCheckAppBetaPasswordResponse_BetaPassword) Reset() { + *m = CMsgClientCheckAppBetaPasswordResponse_BetaPassword{} +} +func (m *CMsgClientCheckAppBetaPasswordResponse_BetaPassword) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientCheckAppBetaPasswordResponse_BetaPassword) ProtoMessage() {} +func (*CMsgClientCheckAppBetaPasswordResponse_BetaPassword) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{71, 0} +} + +func (m *CMsgClientCheckAppBetaPasswordResponse_BetaPassword) GetBetaname() string { + if m != nil && m.Betaname != nil { + return *m.Betaname + } + return "" +} + +func (m *CMsgClientCheckAppBetaPasswordResponse_BetaPassword) GetBetapassword() string { + if m != nil && m.Betapassword != nil { + return *m.Betapassword + } + return "" +} + +type CMsgClientUpdateAppJobReport struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + DepotIds []uint32 `protobuf:"varint,2,rep,name=depot_ids" json:"depot_ids,omitempty"` + AppState *uint32 `protobuf:"varint,3,opt,name=app_state" json:"app_state,omitempty"` + JobAppError *uint32 `protobuf:"varint,4,opt,name=job_app_error" json:"job_app_error,omitempty"` + ErrorDetails *string `protobuf:"bytes,5,opt,name=error_details" json:"error_details,omitempty"` + JobDuration *uint32 `protobuf:"varint,6,opt,name=job_duration" json:"job_duration,omitempty"` + FilesValidationFailed *uint32 `protobuf:"varint,7,opt,name=files_validation_failed" json:"files_validation_failed,omitempty"` + BytesDownloaded *uint64 `protobuf:"varint,8,opt,name=bytes_downloaded" json:"bytes_downloaded,omitempty"` + BytesStaged *uint64 `protobuf:"varint,9,opt,name=bytes_staged" json:"bytes_staged,omitempty"` + BytesComitted *uint64 `protobuf:"varint,10,opt,name=bytes_comitted" json:"bytes_comitted,omitempty"` + StartAppState *uint32 `protobuf:"varint,11,opt,name=start_app_state" json:"start_app_state,omitempty"` + StatsMachineId *uint64 `protobuf:"fixed64,12,opt,name=stats_machine_id" json:"stats_machine_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUpdateAppJobReport) Reset() { *m = CMsgClientUpdateAppJobReport{} } +func (m *CMsgClientUpdateAppJobReport) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUpdateAppJobReport) ProtoMessage() {} +func (*CMsgClientUpdateAppJobReport) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{72} } + +func (m *CMsgClientUpdateAppJobReport) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetDepotIds() []uint32 { + if m != nil { + return m.DepotIds + } + return nil +} + +func (m *CMsgClientUpdateAppJobReport) GetAppState() uint32 { + if m != nil && m.AppState != nil { + return *m.AppState + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetJobAppError() uint32 { + if m != nil && m.JobAppError != nil { + return *m.JobAppError + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetErrorDetails() string { + if m != nil && m.ErrorDetails != nil { + return *m.ErrorDetails + } + return "" +} + +func (m *CMsgClientUpdateAppJobReport) GetJobDuration() uint32 { + if m != nil && m.JobDuration != nil { + return *m.JobDuration + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetFilesValidationFailed() uint32 { + if m != nil && m.FilesValidationFailed != nil { + return *m.FilesValidationFailed + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetBytesDownloaded() uint64 { + if m != nil && m.BytesDownloaded != nil { + return *m.BytesDownloaded + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetBytesStaged() uint64 { + if m != nil && m.BytesStaged != nil { + return *m.BytesStaged + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetBytesComitted() uint64 { + if m != nil && m.BytesComitted != nil { + return *m.BytesComitted + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetStartAppState() uint32 { + if m != nil && m.StartAppState != nil { + return *m.StartAppState + } + return 0 +} + +func (m *CMsgClientUpdateAppJobReport) GetStatsMachineId() uint64 { + if m != nil && m.StatsMachineId != nil { + return *m.StatsMachineId + } + return 0 +} + +type CMsgClientDPContentStatsReport struct { + StatsMachineId *uint64 `protobuf:"fixed64,1,opt,name=stats_machine_id" json:"stats_machine_id,omitempty"` + CountryCode *string `protobuf:"bytes,2,opt,name=country_code" json:"country_code,omitempty"` + OsType *int32 `protobuf:"varint,3,opt,name=os_type" json:"os_type,omitempty"` + Language *int32 `protobuf:"varint,4,opt,name=language" json:"language,omitempty"` + NumInstallFolders *uint32 `protobuf:"varint,5,opt,name=num_install_folders" json:"num_install_folders,omitempty"` + NumInstalledGames *uint32 `protobuf:"varint,6,opt,name=num_installed_games" json:"num_installed_games,omitempty"` + SizeInstalledGames *uint64 `protobuf:"varint,7,opt,name=size_installed_games" json:"size_installed_games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDPContentStatsReport) Reset() { *m = CMsgClientDPContentStatsReport{} } +func (m *CMsgClientDPContentStatsReport) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDPContentStatsReport) ProtoMessage() {} +func (*CMsgClientDPContentStatsReport) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{73} } + +func (m *CMsgClientDPContentStatsReport) GetStatsMachineId() uint64 { + if m != nil && m.StatsMachineId != nil { + return *m.StatsMachineId + } + return 0 +} + +func (m *CMsgClientDPContentStatsReport) GetCountryCode() string { + if m != nil && m.CountryCode != nil { + return *m.CountryCode + } + return "" +} + +func (m *CMsgClientDPContentStatsReport) GetOsType() int32 { + if m != nil && m.OsType != nil { + return *m.OsType + } + return 0 +} + +func (m *CMsgClientDPContentStatsReport) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return 0 +} + +func (m *CMsgClientDPContentStatsReport) GetNumInstallFolders() uint32 { + if m != nil && m.NumInstallFolders != nil { + return *m.NumInstallFolders + } + return 0 +} + +func (m *CMsgClientDPContentStatsReport) GetNumInstalledGames() uint32 { + if m != nil && m.NumInstalledGames != nil { + return *m.NumInstalledGames + } + return 0 +} + +func (m *CMsgClientDPContentStatsReport) GetSizeInstalledGames() uint64 { + if m != nil && m.SizeInstalledGames != nil { + return *m.SizeInstalledGames + } + return 0 +} + +type CMsgClientGetCDNAuthTokenResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Token *string `protobuf:"bytes,2,opt,name=token" json:"token,omitempty"` + ExpirationTime *uint32 `protobuf:"varint,3,opt,name=expiration_time" json:"expiration_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetCDNAuthTokenResponse) Reset() { *m = CMsgClientGetCDNAuthTokenResponse{} } +func (m *CMsgClientGetCDNAuthTokenResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetCDNAuthTokenResponse) ProtoMessage() {} +func (*CMsgClientGetCDNAuthTokenResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{74} +} + +const Default_CMsgClientGetCDNAuthTokenResponse_Eresult uint32 = 2 + +func (m *CMsgClientGetCDNAuthTokenResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientGetCDNAuthTokenResponse_Eresult +} + +func (m *CMsgClientGetCDNAuthTokenResponse) GetToken() string { + if m != nil && m.Token != nil { + return *m.Token + } + return "" +} + +func (m *CMsgClientGetCDNAuthTokenResponse) GetExpirationTime() uint32 { + if m != nil && m.ExpirationTime != nil { + return *m.ExpirationTime + } + return 0 +} + +type CMsgDownloadRateStatistics struct { + CellId *uint32 `protobuf:"varint,1,opt,name=cell_id" json:"cell_id,omitempty"` + Stats []*CMsgDownloadRateStatistics_StatsInfo `protobuf:"bytes,2,rep,name=stats" json:"stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDownloadRateStatistics) Reset() { *m = CMsgDownloadRateStatistics{} } +func (m *CMsgDownloadRateStatistics) String() string { return proto.CompactTextString(m) } +func (*CMsgDownloadRateStatistics) ProtoMessage() {} +func (*CMsgDownloadRateStatistics) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{75} } + +func (m *CMsgDownloadRateStatistics) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CMsgDownloadRateStatistics) GetStats() []*CMsgDownloadRateStatistics_StatsInfo { + if m != nil { + return m.Stats + } + return nil +} + +type CMsgDownloadRateStatistics_StatsInfo struct { + SourceType *uint32 `protobuf:"varint,1,opt,name=source_type" json:"source_type,omitempty"` + SourceId *uint32 `protobuf:"varint,2,opt,name=source_id" json:"source_id,omitempty"` + Seconds *uint32 `protobuf:"varint,3,opt,name=seconds" json:"seconds,omitempty"` + Bytes *uint64 `protobuf:"varint,4,opt,name=bytes" json:"bytes,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDownloadRateStatistics_StatsInfo) Reset() { *m = CMsgDownloadRateStatistics_StatsInfo{} } +func (m *CMsgDownloadRateStatistics_StatsInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgDownloadRateStatistics_StatsInfo) ProtoMessage() {} +func (*CMsgDownloadRateStatistics_StatsInfo) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{75, 0} +} + +func (m *CMsgDownloadRateStatistics_StatsInfo) GetSourceType() uint32 { + if m != nil && m.SourceType != nil { + return *m.SourceType + } + return 0 +} + +func (m *CMsgDownloadRateStatistics_StatsInfo) GetSourceId() uint32 { + if m != nil && m.SourceId != nil { + return *m.SourceId + } + return 0 +} + +func (m *CMsgDownloadRateStatistics_StatsInfo) GetSeconds() uint32 { + if m != nil && m.Seconds != nil { + return *m.Seconds + } + return 0 +} + +func (m *CMsgDownloadRateStatistics_StatsInfo) GetBytes() uint64 { + if m != nil && m.Bytes != nil { + return *m.Bytes + } + return 0 +} + +type CMsgClientRequestAccountData struct { + AccountOrEmail *string `protobuf:"bytes,1,opt,name=account_or_email" json:"account_or_email,omitempty"` + Action *uint32 `protobuf:"varint,2,opt,name=action" json:"action,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestAccountData) Reset() { *m = CMsgClientRequestAccountData{} } +func (m *CMsgClientRequestAccountData) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestAccountData) ProtoMessage() {} +func (*CMsgClientRequestAccountData) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{76} } + +func (m *CMsgClientRequestAccountData) GetAccountOrEmail() string { + if m != nil && m.AccountOrEmail != nil { + return *m.AccountOrEmail + } + return "" +} + +func (m *CMsgClientRequestAccountData) GetAction() uint32 { + if m != nil && m.Action != nil { + return *m.Action + } + return 0 +} + +type CMsgClientRequestAccountDataResponse struct { + Action *uint32 `protobuf:"varint,1,opt,name=action" json:"action,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult" json:"eresult,omitempty"` + AccountName *string `protobuf:"bytes,3,opt,name=account_name" json:"account_name,omitempty"` + CtMatches *uint32 `protobuf:"varint,4,opt,name=ct_matches" json:"ct_matches,omitempty"` + AccountNameSuggestion1 *string `protobuf:"bytes,5,opt,name=account_name_suggestion1" json:"account_name_suggestion1,omitempty"` + AccountNameSuggestion2 *string `protobuf:"bytes,6,opt,name=account_name_suggestion2" json:"account_name_suggestion2,omitempty"` + AccountNameSuggestion3 *string `protobuf:"bytes,7,opt,name=account_name_suggestion3" json:"account_name_suggestion3,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestAccountDataResponse) Reset() { *m = CMsgClientRequestAccountDataResponse{} } +func (m *CMsgClientRequestAccountDataResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestAccountDataResponse) ProtoMessage() {} +func (*CMsgClientRequestAccountDataResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{77} +} + +func (m *CMsgClientRequestAccountDataResponse) GetAction() uint32 { + if m != nil && m.Action != nil { + return *m.Action + } + return 0 +} + +func (m *CMsgClientRequestAccountDataResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return 0 +} + +func (m *CMsgClientRequestAccountDataResponse) GetAccountName() string { + if m != nil && m.AccountName != nil { + return *m.AccountName + } + return "" +} + +func (m *CMsgClientRequestAccountDataResponse) GetCtMatches() uint32 { + if m != nil && m.CtMatches != nil { + return *m.CtMatches + } + return 0 +} + +func (m *CMsgClientRequestAccountDataResponse) GetAccountNameSuggestion1() string { + if m != nil && m.AccountNameSuggestion1 != nil { + return *m.AccountNameSuggestion1 + } + return "" +} + +func (m *CMsgClientRequestAccountDataResponse) GetAccountNameSuggestion2() string { + if m != nil && m.AccountNameSuggestion2 != nil { + return *m.AccountNameSuggestion2 + } + return "" +} + +func (m *CMsgClientRequestAccountDataResponse) GetAccountNameSuggestion3() string { + if m != nil && m.AccountNameSuggestion3 != nil { + return *m.AccountNameSuggestion3 + } + return "" +} + +type CMsgClientUGSGetGlobalStats struct { + Gameid *uint64 `protobuf:"varint,1,opt,name=gameid" json:"gameid,omitempty"` + HistoryDaysRequested *uint32 `protobuf:"varint,2,opt,name=history_days_requested" json:"history_days_requested,omitempty"` + TimeLastRequested *uint32 `protobuf:"fixed32,3,opt,name=time_last_requested" json:"time_last_requested,omitempty"` + FirstDayCached *uint32 `protobuf:"varint,4,opt,name=first_day_cached" json:"first_day_cached,omitempty"` + DaysCached *uint32 `protobuf:"varint,5,opt,name=days_cached" json:"days_cached,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUGSGetGlobalStats) Reset() { *m = CMsgClientUGSGetGlobalStats{} } +func (m *CMsgClientUGSGetGlobalStats) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUGSGetGlobalStats) ProtoMessage() {} +func (*CMsgClientUGSGetGlobalStats) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{78} } + +func (m *CMsgClientUGSGetGlobalStats) GetGameid() uint64 { + if m != nil && m.Gameid != nil { + return *m.Gameid + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStats) GetHistoryDaysRequested() uint32 { + if m != nil && m.HistoryDaysRequested != nil { + return *m.HistoryDaysRequested + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStats) GetTimeLastRequested() uint32 { + if m != nil && m.TimeLastRequested != nil { + return *m.TimeLastRequested + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStats) GetFirstDayCached() uint32 { + if m != nil && m.FirstDayCached != nil { + return *m.FirstDayCached + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStats) GetDaysCached() uint32 { + if m != nil && m.DaysCached != nil { + return *m.DaysCached + } + return 0 +} + +type CMsgClientUGSGetGlobalStatsResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Timestamp *uint32 `protobuf:"fixed32,2,opt,name=timestamp" json:"timestamp,omitempty"` + DayCurrent *int32 `protobuf:"varint,3,opt,name=day_current" json:"day_current,omitempty"` + Days []*CMsgClientUGSGetGlobalStatsResponse_Day `protobuf:"bytes,4,rep,name=days" json:"days,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUGSGetGlobalStatsResponse) Reset() { *m = CMsgClientUGSGetGlobalStatsResponse{} } +func (m *CMsgClientUGSGetGlobalStatsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUGSGetGlobalStatsResponse) ProtoMessage() {} +func (*CMsgClientUGSGetGlobalStatsResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{79} +} + +const Default_CMsgClientUGSGetGlobalStatsResponse_Eresult int32 = 2 + +func (m *CMsgClientUGSGetGlobalStatsResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientUGSGetGlobalStatsResponse_Eresult +} + +func (m *CMsgClientUGSGetGlobalStatsResponse) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStatsResponse) GetDayCurrent() int32 { + if m != nil && m.DayCurrent != nil { + return *m.DayCurrent + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStatsResponse) GetDays() []*CMsgClientUGSGetGlobalStatsResponse_Day { + if m != nil { + return m.Days + } + return nil +} + +type CMsgClientUGSGetGlobalStatsResponse_Day struct { + DayId *uint32 `protobuf:"varint,1,opt,name=day_id" json:"day_id,omitempty"` + Stats []*CMsgClientUGSGetGlobalStatsResponse_Day_Stat `protobuf:"bytes,2,rep,name=stats" json:"stats,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUGSGetGlobalStatsResponse_Day) Reset() { + *m = CMsgClientUGSGetGlobalStatsResponse_Day{} +} +func (m *CMsgClientUGSGetGlobalStatsResponse_Day) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUGSGetGlobalStatsResponse_Day) ProtoMessage() {} +func (*CMsgClientUGSGetGlobalStatsResponse_Day) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{79, 0} +} + +func (m *CMsgClientUGSGetGlobalStatsResponse_Day) GetDayId() uint32 { + if m != nil && m.DayId != nil { + return *m.DayId + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStatsResponse_Day) GetStats() []*CMsgClientUGSGetGlobalStatsResponse_Day_Stat { + if m != nil { + return m.Stats + } + return nil +} + +type CMsgClientUGSGetGlobalStatsResponse_Day_Stat struct { + StatId *int32 `protobuf:"varint,1,opt,name=stat_id" json:"stat_id,omitempty"` + Data *int64 `protobuf:"varint,2,opt,name=data" json:"data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUGSGetGlobalStatsResponse_Day_Stat) Reset() { + *m = CMsgClientUGSGetGlobalStatsResponse_Day_Stat{} +} +func (m *CMsgClientUGSGetGlobalStatsResponse_Day_Stat) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUGSGetGlobalStatsResponse_Day_Stat) ProtoMessage() {} +func (*CMsgClientUGSGetGlobalStatsResponse_Day_Stat) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{79, 0, 0} +} + +func (m *CMsgClientUGSGetGlobalStatsResponse_Day_Stat) GetStatId() int32 { + if m != nil && m.StatId != nil { + return *m.StatId + } + return 0 +} + +func (m *CMsgClientUGSGetGlobalStatsResponse_Day_Stat) GetData() int64 { + if m != nil && m.Data != nil { + return *m.Data + } + return 0 +} + +type CMsgGameServerData struct { + SteamIdGs *uint64 `protobuf:"fixed64,1,opt,name=steam_id_gs" json:"steam_id_gs,omitempty"` + Ip *uint32 `protobuf:"varint,2,opt,name=ip" json:"ip,omitempty"` + QueryPort *uint32 `protobuf:"varint,3,opt,name=query_port" json:"query_port,omitempty"` + GamePort *uint32 `protobuf:"varint,4,opt,name=game_port" json:"game_port,omitempty"` + SourcetvPort *uint32 `protobuf:"varint,5,opt,name=sourcetv_port" json:"sourcetv_port,omitempty"` + Name *string `protobuf:"bytes,22,opt,name=name" json:"name,omitempty"` + AppId *uint32 `protobuf:"varint,6,opt,name=app_id" json:"app_id,omitempty"` + Gamedir *string `protobuf:"bytes,7,opt,name=gamedir" json:"gamedir,omitempty"` + Version *string `protobuf:"bytes,8,opt,name=version" json:"version,omitempty"` + Product *string `protobuf:"bytes,9,opt,name=product" json:"product,omitempty"` + Region *string `protobuf:"bytes,10,opt,name=region" json:"region,omitempty"` + Players []*CMsgGameServerData_Player `protobuf:"bytes,11,rep,name=players" json:"players,omitempty"` + MaxPlayers *uint32 `protobuf:"varint,12,opt,name=max_players" json:"max_players,omitempty"` + BotCount *uint32 `protobuf:"varint,13,opt,name=bot_count" json:"bot_count,omitempty"` + Password *bool `protobuf:"varint,14,opt,name=password" json:"password,omitempty"` + Secure *bool `protobuf:"varint,15,opt,name=secure" json:"secure,omitempty"` + Dedicated *bool `protobuf:"varint,16,opt,name=dedicated" json:"dedicated,omitempty"` + Os *string `protobuf:"bytes,17,opt,name=os" json:"os,omitempty"` + GameData *string `protobuf:"bytes,18,opt,name=game_data" json:"game_data,omitempty"` + GameDataVersion *uint32 `protobuf:"varint,19,opt,name=game_data_version" json:"game_data_version,omitempty"` + GameType *string `protobuf:"bytes,20,opt,name=game_type" json:"game_type,omitempty"` + Map *string `protobuf:"bytes,21,opt,name=map" json:"map,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGameServerData) Reset() { *m = CMsgGameServerData{} } +func (m *CMsgGameServerData) String() string { return proto.CompactTextString(m) } +func (*CMsgGameServerData) ProtoMessage() {} +func (*CMsgGameServerData) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{80} } + +func (m *CMsgGameServerData) GetSteamIdGs() uint64 { + if m != nil && m.SteamIdGs != nil { + return *m.SteamIdGs + } + return 0 +} + +func (m *CMsgGameServerData) GetIp() uint32 { + if m != nil && m.Ip != nil { + return *m.Ip + } + return 0 +} + +func (m *CMsgGameServerData) GetQueryPort() uint32 { + if m != nil && m.QueryPort != nil { + return *m.QueryPort + } + return 0 +} + +func (m *CMsgGameServerData) GetGamePort() uint32 { + if m != nil && m.GamePort != nil { + return *m.GamePort + } + return 0 +} + +func (m *CMsgGameServerData) GetSourcetvPort() uint32 { + if m != nil && m.SourcetvPort != nil { + return *m.SourcetvPort + } + return 0 +} + +func (m *CMsgGameServerData) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgGameServerData) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgGameServerData) GetGamedir() string { + if m != nil && m.Gamedir != nil { + return *m.Gamedir + } + return "" +} + +func (m *CMsgGameServerData) GetVersion() string { + if m != nil && m.Version != nil { + return *m.Version + } + return "" +} + +func (m *CMsgGameServerData) GetProduct() string { + if m != nil && m.Product != nil { + return *m.Product + } + return "" +} + +func (m *CMsgGameServerData) GetRegion() string { + if m != nil && m.Region != nil { + return *m.Region + } + return "" +} + +func (m *CMsgGameServerData) GetPlayers() []*CMsgGameServerData_Player { + if m != nil { + return m.Players + } + return nil +} + +func (m *CMsgGameServerData) GetMaxPlayers() uint32 { + if m != nil && m.MaxPlayers != nil { + return *m.MaxPlayers + } + return 0 +} + +func (m *CMsgGameServerData) GetBotCount() uint32 { + if m != nil && m.BotCount != nil { + return *m.BotCount + } + return 0 +} + +func (m *CMsgGameServerData) GetPassword() bool { + if m != nil && m.Password != nil { + return *m.Password + } + return false +} + +func (m *CMsgGameServerData) GetSecure() bool { + if m != nil && m.Secure != nil { + return *m.Secure + } + return false +} + +func (m *CMsgGameServerData) GetDedicated() bool { + if m != nil && m.Dedicated != nil { + return *m.Dedicated + } + return false +} + +func (m *CMsgGameServerData) GetOs() string { + if m != nil && m.Os != nil { + return *m.Os + } + return "" +} + +func (m *CMsgGameServerData) GetGameData() string { + if m != nil && m.GameData != nil { + return *m.GameData + } + return "" +} + +func (m *CMsgGameServerData) GetGameDataVersion() uint32 { + if m != nil && m.GameDataVersion != nil { + return *m.GameDataVersion + } + return 0 +} + +func (m *CMsgGameServerData) GetGameType() string { + if m != nil && m.GameType != nil { + return *m.GameType + } + return "" +} + +func (m *CMsgGameServerData) GetMap() string { + if m != nil && m.Map != nil { + return *m.Map + } + return "" +} + +type CMsgGameServerData_Player struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGameServerData_Player) Reset() { *m = CMsgGameServerData_Player{} } +func (m *CMsgGameServerData_Player) String() string { return proto.CompactTextString(m) } +func (*CMsgGameServerData_Player) ProtoMessage() {} +func (*CMsgGameServerData_Player) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{80, 0} } + +func (m *CMsgGameServerData_Player) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CMsgGameServerRemove struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + Ip *uint32 `protobuf:"varint,2,opt,name=ip" json:"ip,omitempty"` + QueryPort *uint32 `protobuf:"varint,3,opt,name=query_port" json:"query_port,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGameServerRemove) Reset() { *m = CMsgGameServerRemove{} } +func (m *CMsgGameServerRemove) String() string { return proto.CompactTextString(m) } +func (*CMsgGameServerRemove) ProtoMessage() {} +func (*CMsgGameServerRemove) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{81} } + +func (m *CMsgGameServerRemove) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +func (m *CMsgGameServerRemove) GetIp() uint32 { + if m != nil && m.Ip != nil { + return *m.Ip + } + return 0 +} + +func (m *CMsgGameServerRemove) GetQueryPort() uint32 { + if m != nil && m.QueryPort != nil { + return *m.QueryPort + } + return 0 +} + +type CMsgClientGMSServerQuery struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + GeoLocationIp *uint32 `protobuf:"varint,2,opt,name=geo_location_ip" json:"geo_location_ip,omitempty"` + RegionCode *uint32 `protobuf:"varint,3,opt,name=region_code" json:"region_code,omitempty"` + FilterText *string `protobuf:"bytes,4,opt,name=filter_text" json:"filter_text,omitempty"` + MaxServers *uint32 `protobuf:"varint,5,opt,name=max_servers" json:"max_servers,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGMSServerQuery) Reset() { *m = CMsgClientGMSServerQuery{} } +func (m *CMsgClientGMSServerQuery) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGMSServerQuery) ProtoMessage() {} +func (*CMsgClientGMSServerQuery) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{82} } + +func (m *CMsgClientGMSServerQuery) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientGMSServerQuery) GetGeoLocationIp() uint32 { + if m != nil && m.GeoLocationIp != nil { + return *m.GeoLocationIp + } + return 0 +} + +func (m *CMsgClientGMSServerQuery) GetRegionCode() uint32 { + if m != nil && m.RegionCode != nil { + return *m.RegionCode + } + return 0 +} + +func (m *CMsgClientGMSServerQuery) GetFilterText() string { + if m != nil && m.FilterText != nil { + return *m.FilterText + } + return "" +} + +func (m *CMsgClientGMSServerQuery) GetMaxServers() uint32 { + if m != nil && m.MaxServers != nil { + return *m.MaxServers + } + return 0 +} + +type CMsgGMSClientServerQueryResponse struct { + Servers []*CMsgGMSClientServerQueryResponse_Server `protobuf:"bytes,1,rep,name=servers" json:"servers,omitempty"` + Error *string `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGMSClientServerQueryResponse) Reset() { *m = CMsgGMSClientServerQueryResponse{} } +func (m *CMsgGMSClientServerQueryResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGMSClientServerQueryResponse) ProtoMessage() {} +func (*CMsgGMSClientServerQueryResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{83} +} + +func (m *CMsgGMSClientServerQueryResponse) GetServers() []*CMsgGMSClientServerQueryResponse_Server { + if m != nil { + return m.Servers + } + return nil +} + +func (m *CMsgGMSClientServerQueryResponse) GetError() string { + if m != nil && m.Error != nil { + return *m.Error + } + return "" +} + +type CMsgGMSClientServerQueryResponse_Server struct { + ServerIp *uint32 `protobuf:"varint,1,opt,name=server_ip" json:"server_ip,omitempty"` + ServerPort *uint32 `protobuf:"varint,2,opt,name=server_port" json:"server_port,omitempty"` + AuthPlayers *uint32 `protobuf:"varint,3,opt,name=auth_players" json:"auth_players,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGMSClientServerQueryResponse_Server) Reset() { + *m = CMsgGMSClientServerQueryResponse_Server{} +} +func (m *CMsgGMSClientServerQueryResponse_Server) String() string { return proto.CompactTextString(m) } +func (*CMsgGMSClientServerQueryResponse_Server) ProtoMessage() {} +func (*CMsgGMSClientServerQueryResponse_Server) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{83, 0} +} + +func (m *CMsgGMSClientServerQueryResponse_Server) GetServerIp() uint32 { + if m != nil && m.ServerIp != nil { + return *m.ServerIp + } + return 0 +} + +func (m *CMsgGMSClientServerQueryResponse_Server) GetServerPort() uint32 { + if m != nil && m.ServerPort != nil { + return *m.ServerPort + } + return 0 +} + +func (m *CMsgGMSClientServerQueryResponse_Server) GetAuthPlayers() uint32 { + if m != nil && m.AuthPlayers != nil { + return *m.AuthPlayers + } + return 0 +} + +type CMsgGameServerOutOfDate struct { + SteamIdGs *uint64 `protobuf:"fixed64,1,opt,name=steam_id_gs" json:"steam_id_gs,omitempty"` + Reject *bool `protobuf:"varint,2,opt,name=reject" json:"reject,omitempty"` + Message *string `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGameServerOutOfDate) Reset() { *m = CMsgGameServerOutOfDate{} } +func (m *CMsgGameServerOutOfDate) String() string { return proto.CompactTextString(m) } +func (*CMsgGameServerOutOfDate) ProtoMessage() {} +func (*CMsgGameServerOutOfDate) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{84} } + +func (m *CMsgGameServerOutOfDate) GetSteamIdGs() uint64 { + if m != nil && m.SteamIdGs != nil { + return *m.SteamIdGs + } + return 0 +} + +func (m *CMsgGameServerOutOfDate) GetReject() bool { + if m != nil && m.Reject != nil { + return *m.Reject + } + return false +} + +func (m *CMsgGameServerOutOfDate) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +type CMsgClientRedeemGuestPass struct { + GuestPassId *uint64 `protobuf:"fixed64,1,opt,name=guest_pass_id" json:"guest_pass_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRedeemGuestPass) Reset() { *m = CMsgClientRedeemGuestPass{} } +func (m *CMsgClientRedeemGuestPass) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRedeemGuestPass) ProtoMessage() {} +func (*CMsgClientRedeemGuestPass) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{85} } + +func (m *CMsgClientRedeemGuestPass) GetGuestPassId() uint64 { + if m != nil && m.GuestPassId != nil { + return *m.GuestPassId + } + return 0 +} + +type CMsgClientRedeemGuestPassResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PackageId *uint32 `protobuf:"varint,2,opt,name=package_id" json:"package_id,omitempty"` + MustOwnAppid *uint32 `protobuf:"varint,3,opt,name=must_own_appid" json:"must_own_appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRedeemGuestPassResponse) Reset() { *m = CMsgClientRedeemGuestPassResponse{} } +func (m *CMsgClientRedeemGuestPassResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRedeemGuestPassResponse) ProtoMessage() {} +func (*CMsgClientRedeemGuestPassResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{86} +} + +const Default_CMsgClientRedeemGuestPassResponse_Eresult uint32 = 2 + +func (m *CMsgClientRedeemGuestPassResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientRedeemGuestPassResponse_Eresult +} + +func (m *CMsgClientRedeemGuestPassResponse) GetPackageId() uint32 { + if m != nil && m.PackageId != nil { + return *m.PackageId + } + return 0 +} + +func (m *CMsgClientRedeemGuestPassResponse) GetMustOwnAppid() uint32 { + if m != nil && m.MustOwnAppid != nil { + return *m.MustOwnAppid + } + return 0 +} + +type CMsgClientGetClanActivityCounts struct { + SteamidClans []uint64 `protobuf:"varint,1,rep,name=steamid_clans" json:"steamid_clans,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClanActivityCounts) Reset() { *m = CMsgClientGetClanActivityCounts{} } +func (m *CMsgClientGetClanActivityCounts) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClanActivityCounts) ProtoMessage() {} +func (*CMsgClientGetClanActivityCounts) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{87} +} + +func (m *CMsgClientGetClanActivityCounts) GetSteamidClans() []uint64 { + if m != nil { + return m.SteamidClans + } + return nil +} + +type CMsgClientGetClanActivityCountsResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetClanActivityCountsResponse) Reset() { + *m = CMsgClientGetClanActivityCountsResponse{} +} +func (m *CMsgClientGetClanActivityCountsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetClanActivityCountsResponse) ProtoMessage() {} +func (*CMsgClientGetClanActivityCountsResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{88} +} + +const Default_CMsgClientGetClanActivityCountsResponse_Eresult uint32 = 2 + +func (m *CMsgClientGetClanActivityCountsResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientGetClanActivityCountsResponse_Eresult +} + +type CMsgClientOGSReportString struct { + Accumulated *bool `protobuf:"varint,1,opt,name=accumulated" json:"accumulated,omitempty"` + Sessionid *uint64 `protobuf:"varint,2,opt,name=sessionid" json:"sessionid,omitempty"` + Severity *int32 `protobuf:"varint,3,opt,name=severity" json:"severity,omitempty"` + Formatter *string `protobuf:"bytes,4,opt,name=formatter" json:"formatter,omitempty"` + Varargs []byte `protobuf:"bytes,5,opt,name=varargs" json:"varargs,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientOGSReportString) Reset() { *m = CMsgClientOGSReportString{} } +func (m *CMsgClientOGSReportString) String() string { return proto.CompactTextString(m) } +func (*CMsgClientOGSReportString) ProtoMessage() {} +func (*CMsgClientOGSReportString) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{89} } + +func (m *CMsgClientOGSReportString) GetAccumulated() bool { + if m != nil && m.Accumulated != nil { + return *m.Accumulated + } + return false +} + +func (m *CMsgClientOGSReportString) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +func (m *CMsgClientOGSReportString) GetSeverity() int32 { + if m != nil && m.Severity != nil { + return *m.Severity + } + return 0 +} + +func (m *CMsgClientOGSReportString) GetFormatter() string { + if m != nil && m.Formatter != nil { + return *m.Formatter + } + return "" +} + +func (m *CMsgClientOGSReportString) GetVarargs() []byte { + if m != nil { + return m.Varargs + } + return nil +} + +type CMsgClientOGSReportBug struct { + Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"` + Bugtext *string `protobuf:"bytes,2,opt,name=bugtext" json:"bugtext,omitempty"` + Screenshot []byte `protobuf:"bytes,3,opt,name=screenshot" json:"screenshot,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientOGSReportBug) Reset() { *m = CMsgClientOGSReportBug{} } +func (m *CMsgClientOGSReportBug) String() string { return proto.CompactTextString(m) } +func (*CMsgClientOGSReportBug) ProtoMessage() {} +func (*CMsgClientOGSReportBug) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{90} } + +func (m *CMsgClientOGSReportBug) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +func (m *CMsgClientOGSReportBug) GetBugtext() string { + if m != nil && m.Bugtext != nil { + return *m.Bugtext + } + return "" +} + +func (m *CMsgClientOGSReportBug) GetScreenshot() []byte { + if m != nil { + return m.Screenshot + } + return nil +} + +type CMsgGSAssociateWithClan struct { + SteamIdClan *uint64 `protobuf:"fixed64,1,opt,name=steam_id_clan" json:"steam_id_clan,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSAssociateWithClan) Reset() { *m = CMsgGSAssociateWithClan{} } +func (m *CMsgGSAssociateWithClan) String() string { return proto.CompactTextString(m) } +func (*CMsgGSAssociateWithClan) ProtoMessage() {} +func (*CMsgGSAssociateWithClan) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{91} } + +func (m *CMsgGSAssociateWithClan) GetSteamIdClan() uint64 { + if m != nil && m.SteamIdClan != nil { + return *m.SteamIdClan + } + return 0 +} + +type CMsgGSAssociateWithClanResponse struct { + SteamIdClan *uint64 `protobuf:"fixed64,1,opt,name=steam_id_clan" json:"steam_id_clan,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSAssociateWithClanResponse) Reset() { *m = CMsgGSAssociateWithClanResponse{} } +func (m *CMsgGSAssociateWithClanResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgGSAssociateWithClanResponse) ProtoMessage() {} +func (*CMsgGSAssociateWithClanResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{92} +} + +const Default_CMsgGSAssociateWithClanResponse_Eresult uint32 = 2 + +func (m *CMsgGSAssociateWithClanResponse) GetSteamIdClan() uint64 { + if m != nil && m.SteamIdClan != nil { + return *m.SteamIdClan + } + return 0 +} + +func (m *CMsgGSAssociateWithClanResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgGSAssociateWithClanResponse_Eresult +} + +type CMsgGSComputeNewPlayerCompatibility struct { + SteamIdCandidate *uint64 `protobuf:"fixed64,1,opt,name=steam_id_candidate" json:"steam_id_candidate,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSComputeNewPlayerCompatibility) Reset() { *m = CMsgGSComputeNewPlayerCompatibility{} } +func (m *CMsgGSComputeNewPlayerCompatibility) String() string { return proto.CompactTextString(m) } +func (*CMsgGSComputeNewPlayerCompatibility) ProtoMessage() {} +func (*CMsgGSComputeNewPlayerCompatibility) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{93} +} + +func (m *CMsgGSComputeNewPlayerCompatibility) GetSteamIdCandidate() uint64 { + if m != nil && m.SteamIdCandidate != nil { + return *m.SteamIdCandidate + } + return 0 +} + +type CMsgGSComputeNewPlayerCompatibilityResponse struct { + SteamIdCandidate *uint64 `protobuf:"fixed64,1,opt,name=steam_id_candidate" json:"steam_id_candidate,omitempty"` + Eresult *uint32 `protobuf:"varint,2,opt,name=eresult,def=2" json:"eresult,omitempty"` + IsClanMember *bool `protobuf:"varint,3,opt,name=is_clan_member" json:"is_clan_member,omitempty"` + CtDontLikeYou *int32 `protobuf:"varint,4,opt,name=ct_dont_like_you" json:"ct_dont_like_you,omitempty"` + CtYouDontLike *int32 `protobuf:"varint,5,opt,name=ct_you_dont_like" json:"ct_you_dont_like,omitempty"` + CtClanmembersDontLikeYou *int32 `protobuf:"varint,6,opt,name=ct_clanmembers_dont_like_you" json:"ct_clanmembers_dont_like_you,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) Reset() { + *m = CMsgGSComputeNewPlayerCompatibilityResponse{} +} +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgGSComputeNewPlayerCompatibilityResponse) ProtoMessage() {} +func (*CMsgGSComputeNewPlayerCompatibilityResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{94} +} + +const Default_CMsgGSComputeNewPlayerCompatibilityResponse_Eresult uint32 = 2 + +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) GetSteamIdCandidate() uint64 { + if m != nil && m.SteamIdCandidate != nil { + return *m.SteamIdCandidate + } + return 0 +} + +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgGSComputeNewPlayerCompatibilityResponse_Eresult +} + +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) GetIsClanMember() bool { + if m != nil && m.IsClanMember != nil { + return *m.IsClanMember + } + return false +} + +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) GetCtDontLikeYou() int32 { + if m != nil && m.CtDontLikeYou != nil { + return *m.CtDontLikeYou + } + return 0 +} + +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) GetCtYouDontLike() int32 { + if m != nil && m.CtYouDontLike != nil { + return *m.CtYouDontLike + } + return 0 +} + +func (m *CMsgGSComputeNewPlayerCompatibilityResponse) GetCtClanmembersDontLikeYou() int32 { + if m != nil && m.CtClanmembersDontLikeYou != nil { + return *m.CtClanmembersDontLikeYou + } + return 0 +} + +type CMsgClientSentLogs struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSentLogs) Reset() { *m = CMsgClientSentLogs{} } +func (m *CMsgClientSentLogs) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSentLogs) ProtoMessage() {} +func (*CMsgClientSentLogs) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{95} } + +type CMsgGCClient struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Msgtype *uint32 `protobuf:"varint,2,opt,name=msgtype" json:"msgtype,omitempty"` + Payload []byte `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"` + Steamid *uint64 `protobuf:"fixed64,4,opt,name=steamid" json:"steamid,omitempty"` + Gcname *string `protobuf:"bytes,5,opt,name=gcname" json:"gcname,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGCClient) Reset() { *m = CMsgGCClient{} } +func (m *CMsgGCClient) String() string { return proto.CompactTextString(m) } +func (*CMsgGCClient) ProtoMessage() {} +func (*CMsgGCClient) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{96} } + +func (m *CMsgGCClient) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgGCClient) GetMsgtype() uint32 { + if m != nil && m.Msgtype != nil { + return *m.Msgtype + } + return 0 +} + +func (m *CMsgGCClient) GetPayload() []byte { + if m != nil { + return m.Payload + } + return nil +} + +func (m *CMsgGCClient) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgGCClient) GetGcname() string { + if m != nil && m.Gcname != nil { + return *m.Gcname + } + return "" +} + +type CMsgClientRequestFreeLicense struct { + Appids []uint32 `protobuf:"varint,2,rep,name=appids" json:"appids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestFreeLicense) Reset() { *m = CMsgClientRequestFreeLicense{} } +func (m *CMsgClientRequestFreeLicense) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestFreeLicense) ProtoMessage() {} +func (*CMsgClientRequestFreeLicense) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{97} } + +func (m *CMsgClientRequestFreeLicense) GetAppids() []uint32 { + if m != nil { + return m.Appids + } + return nil +} + +type CMsgClientRequestFreeLicenseResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + GrantedPackageids []uint32 `protobuf:"varint,2,rep,name=granted_packageids" json:"granted_packageids,omitempty"` + GrantedAppids []uint32 `protobuf:"varint,3,rep,name=granted_appids" json:"granted_appids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestFreeLicenseResponse) Reset() { *m = CMsgClientRequestFreeLicenseResponse{} } +func (m *CMsgClientRequestFreeLicenseResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestFreeLicenseResponse) ProtoMessage() {} +func (*CMsgClientRequestFreeLicenseResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{98} +} + +const Default_CMsgClientRequestFreeLicenseResponse_Eresult uint32 = 2 + +func (m *CMsgClientRequestFreeLicenseResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientRequestFreeLicenseResponse_Eresult +} + +func (m *CMsgClientRequestFreeLicenseResponse) GetGrantedPackageids() []uint32 { + if m != nil { + return m.GrantedPackageids + } + return nil +} + +func (m *CMsgClientRequestFreeLicenseResponse) GetGrantedAppids() []uint32 { + if m != nil { + return m.GrantedAppids + } + return nil +} + +type CMsgDRMDownloadRequestWithCrashData struct { + DownloadFlags *uint32 `protobuf:"varint,1,opt,name=download_flags" json:"download_flags,omitempty"` + DownloadTypesKnown *uint32 `protobuf:"varint,2,opt,name=download_types_known" json:"download_types_known,omitempty"` + GuidDrm []byte `protobuf:"bytes,3,opt,name=guid_drm" json:"guid_drm,omitempty"` + GuidSplit []byte `protobuf:"bytes,4,opt,name=guid_split" json:"guid_split,omitempty"` + GuidMerge []byte `protobuf:"bytes,5,opt,name=guid_merge" json:"guid_merge,omitempty"` + ModuleName *string `protobuf:"bytes,6,opt,name=module_name" json:"module_name,omitempty"` + ModulePath *string `protobuf:"bytes,7,opt,name=module_path" json:"module_path,omitempty"` + CrashData []byte `protobuf:"bytes,8,opt,name=crash_data" json:"crash_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDRMDownloadRequestWithCrashData) Reset() { *m = CMsgDRMDownloadRequestWithCrashData{} } +func (m *CMsgDRMDownloadRequestWithCrashData) String() string { return proto.CompactTextString(m) } +func (*CMsgDRMDownloadRequestWithCrashData) ProtoMessage() {} +func (*CMsgDRMDownloadRequestWithCrashData) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{99} +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetDownloadFlags() uint32 { + if m != nil && m.DownloadFlags != nil { + return *m.DownloadFlags + } + return 0 +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetDownloadTypesKnown() uint32 { + if m != nil && m.DownloadTypesKnown != nil { + return *m.DownloadTypesKnown + } + return 0 +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetGuidDrm() []byte { + if m != nil { + return m.GuidDrm + } + return nil +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetGuidSplit() []byte { + if m != nil { + return m.GuidSplit + } + return nil +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetGuidMerge() []byte { + if m != nil { + return m.GuidMerge + } + return nil +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetModuleName() string { + if m != nil && m.ModuleName != nil { + return *m.ModuleName + } + return "" +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetModulePath() string { + if m != nil && m.ModulePath != nil { + return *m.ModulePath + } + return "" +} + +func (m *CMsgDRMDownloadRequestWithCrashData) GetCrashData() []byte { + if m != nil { + return m.CrashData + } + return nil +} + +type CMsgDRMDownloadResponse struct { + Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + BlobDownloadType *uint32 `protobuf:"varint,3,opt,name=blob_download_type" json:"blob_download_type,omitempty"` + MergeGuid []byte `protobuf:"bytes,4,opt,name=merge_guid" json:"merge_guid,omitempty"` + DownloadFileDfsIp *uint32 `protobuf:"varint,5,opt,name=download_file_dfs_ip" json:"download_file_dfs_ip,omitempty"` + DownloadFileDfsPort *uint32 `protobuf:"varint,6,opt,name=download_file_dfs_port" json:"download_file_dfs_port,omitempty"` + DownloadFileUrl *string `protobuf:"bytes,7,opt,name=download_file_url" json:"download_file_url,omitempty"` + ModulePath *string `protobuf:"bytes,8,opt,name=module_path" json:"module_path,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDRMDownloadResponse) Reset() { *m = CMsgDRMDownloadResponse{} } +func (m *CMsgDRMDownloadResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDRMDownloadResponse) ProtoMessage() {} +func (*CMsgDRMDownloadResponse) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{100} } + +const Default_CMsgDRMDownloadResponse_Eresult uint32 = 2 + +func (m *CMsgDRMDownloadResponse) GetEresult() uint32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDRMDownloadResponse_Eresult +} + +func (m *CMsgDRMDownloadResponse) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgDRMDownloadResponse) GetBlobDownloadType() uint32 { + if m != nil && m.BlobDownloadType != nil { + return *m.BlobDownloadType + } + return 0 +} + +func (m *CMsgDRMDownloadResponse) GetMergeGuid() []byte { + if m != nil { + return m.MergeGuid + } + return nil +} + +func (m *CMsgDRMDownloadResponse) GetDownloadFileDfsIp() uint32 { + if m != nil && m.DownloadFileDfsIp != nil { + return *m.DownloadFileDfsIp + } + return 0 +} + +func (m *CMsgDRMDownloadResponse) GetDownloadFileDfsPort() uint32 { + if m != nil && m.DownloadFileDfsPort != nil { + return *m.DownloadFileDfsPort + } + return 0 +} + +func (m *CMsgDRMDownloadResponse) GetDownloadFileUrl() string { + if m != nil && m.DownloadFileUrl != nil { + return *m.DownloadFileUrl + } + return "" +} + +func (m *CMsgDRMDownloadResponse) GetModulePath() string { + if m != nil && m.ModulePath != nil { + return *m.ModulePath + } + return "" +} + +type CMsgDRMFinalResult struct { + EResult *uint32 `protobuf:"varint,1,opt,name=eResult,def=2" json:"eResult,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + BlobDownloadType *uint32 `protobuf:"varint,3,opt,name=blob_download_type" json:"blob_download_type,omitempty"` + ErrorDetail *uint32 `protobuf:"varint,4,opt,name=error_detail" json:"error_detail,omitempty"` + MergeGuid []byte `protobuf:"bytes,5,opt,name=merge_guid" json:"merge_guid,omitempty"` + DownloadFileDfsIp *uint32 `protobuf:"varint,6,opt,name=download_file_dfs_ip" json:"download_file_dfs_ip,omitempty"` + DownloadFileDfsPort *uint32 `protobuf:"varint,7,opt,name=download_file_dfs_port" json:"download_file_dfs_port,omitempty"` + DownloadFileUrl *string `protobuf:"bytes,8,opt,name=download_file_url" json:"download_file_url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDRMFinalResult) Reset() { *m = CMsgDRMFinalResult{} } +func (m *CMsgDRMFinalResult) String() string { return proto.CompactTextString(m) } +func (*CMsgDRMFinalResult) ProtoMessage() {} +func (*CMsgDRMFinalResult) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{101} } + +const Default_CMsgDRMFinalResult_EResult uint32 = 2 + +func (m *CMsgDRMFinalResult) GetEResult() uint32 { + if m != nil && m.EResult != nil { + return *m.EResult + } + return Default_CMsgDRMFinalResult_EResult +} + +func (m *CMsgDRMFinalResult) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgDRMFinalResult) GetBlobDownloadType() uint32 { + if m != nil && m.BlobDownloadType != nil { + return *m.BlobDownloadType + } + return 0 +} + +func (m *CMsgDRMFinalResult) GetErrorDetail() uint32 { + if m != nil && m.ErrorDetail != nil { + return *m.ErrorDetail + } + return 0 +} + +func (m *CMsgDRMFinalResult) GetMergeGuid() []byte { + if m != nil { + return m.MergeGuid + } + return nil +} + +func (m *CMsgDRMFinalResult) GetDownloadFileDfsIp() uint32 { + if m != nil && m.DownloadFileDfsIp != nil { + return *m.DownloadFileDfsIp + } + return 0 +} + +func (m *CMsgDRMFinalResult) GetDownloadFileDfsPort() uint32 { + if m != nil && m.DownloadFileDfsPort != nil { + return *m.DownloadFileDfsPort + } + return 0 +} + +func (m *CMsgDRMFinalResult) GetDownloadFileUrl() string { + if m != nil && m.DownloadFileUrl != nil { + return *m.DownloadFileUrl + } + return "" +} + +type CMsgClientDPCheckSpecialSurvey struct { + SurveyId *uint32 `protobuf:"varint,1,opt,name=survey_id" json:"survey_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDPCheckSpecialSurvey) Reset() { *m = CMsgClientDPCheckSpecialSurvey{} } +func (m *CMsgClientDPCheckSpecialSurvey) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDPCheckSpecialSurvey) ProtoMessage() {} +func (*CMsgClientDPCheckSpecialSurvey) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{102} +} + +func (m *CMsgClientDPCheckSpecialSurvey) GetSurveyId() uint32 { + if m != nil && m.SurveyId != nil { + return *m.SurveyId + } + return 0 +} + +type CMsgClientDPCheckSpecialSurveyResponse struct { + EResult *uint32 `protobuf:"varint,1,opt,name=eResult,def=2" json:"eResult,omitempty"` + State *uint32 `protobuf:"varint,2,opt,name=state" json:"state,omitempty"` + Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` + CustomUrl *string `protobuf:"bytes,4,opt,name=custom_url" json:"custom_url,omitempty"` + IncludeSoftware *bool `protobuf:"varint,5,opt,name=include_software" json:"include_software,omitempty"` + Token []byte `protobuf:"bytes,6,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDPCheckSpecialSurveyResponse) Reset() { + *m = CMsgClientDPCheckSpecialSurveyResponse{} +} +func (m *CMsgClientDPCheckSpecialSurveyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDPCheckSpecialSurveyResponse) ProtoMessage() {} +func (*CMsgClientDPCheckSpecialSurveyResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{103} +} + +const Default_CMsgClientDPCheckSpecialSurveyResponse_EResult uint32 = 2 + +func (m *CMsgClientDPCheckSpecialSurveyResponse) GetEResult() uint32 { + if m != nil && m.EResult != nil { + return *m.EResult + } + return Default_CMsgClientDPCheckSpecialSurveyResponse_EResult +} + +func (m *CMsgClientDPCheckSpecialSurveyResponse) GetState() uint32 { + if m != nil && m.State != nil { + return *m.State + } + return 0 +} + +func (m *CMsgClientDPCheckSpecialSurveyResponse) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgClientDPCheckSpecialSurveyResponse) GetCustomUrl() string { + if m != nil && m.CustomUrl != nil { + return *m.CustomUrl + } + return "" +} + +func (m *CMsgClientDPCheckSpecialSurveyResponse) GetIncludeSoftware() bool { + if m != nil && m.IncludeSoftware != nil { + return *m.IncludeSoftware + } + return false +} + +func (m *CMsgClientDPCheckSpecialSurveyResponse) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +type CMsgClientDPSendSpecialSurveyResponse struct { + SurveyId *uint32 `protobuf:"varint,1,opt,name=survey_id" json:"survey_id,omitempty"` + Data []byte `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDPSendSpecialSurveyResponse) Reset() { *m = CMsgClientDPSendSpecialSurveyResponse{} } +func (m *CMsgClientDPSendSpecialSurveyResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDPSendSpecialSurveyResponse) ProtoMessage() {} +func (*CMsgClientDPSendSpecialSurveyResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{104} +} + +func (m *CMsgClientDPSendSpecialSurveyResponse) GetSurveyId() uint32 { + if m != nil && m.SurveyId != nil { + return *m.SurveyId + } + return 0 +} + +func (m *CMsgClientDPSendSpecialSurveyResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +type CMsgClientDPSendSpecialSurveyResponseReply struct { + EResult *uint32 `protobuf:"varint,1,opt,name=eResult,def=2" json:"eResult,omitempty"` + Token []byte `protobuf:"bytes,2,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDPSendSpecialSurveyResponseReply) Reset() { + *m = CMsgClientDPSendSpecialSurveyResponseReply{} +} +func (m *CMsgClientDPSendSpecialSurveyResponseReply) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientDPSendSpecialSurveyResponseReply) ProtoMessage() {} +func (*CMsgClientDPSendSpecialSurveyResponseReply) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{105} +} + +const Default_CMsgClientDPSendSpecialSurveyResponseReply_EResult uint32 = 2 + +func (m *CMsgClientDPSendSpecialSurveyResponseReply) GetEResult() uint32 { + if m != nil && m.EResult != nil { + return *m.EResult + } + return Default_CMsgClientDPSendSpecialSurveyResponseReply_EResult +} + +func (m *CMsgClientDPSendSpecialSurveyResponseReply) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +type CMsgClientRequestForgottenPasswordEmail struct { + AccountName *string `protobuf:"bytes,1,opt,name=account_name" json:"account_name,omitempty"` + PasswordTried *string `protobuf:"bytes,2,opt,name=password_tried" json:"password_tried,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestForgottenPasswordEmail) Reset() { + *m = CMsgClientRequestForgottenPasswordEmail{} +} +func (m *CMsgClientRequestForgottenPasswordEmail) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestForgottenPasswordEmail) ProtoMessage() {} +func (*CMsgClientRequestForgottenPasswordEmail) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{106} +} + +func (m *CMsgClientRequestForgottenPasswordEmail) GetAccountName() string { + if m != nil && m.AccountName != nil { + return *m.AccountName + } + return "" +} + +func (m *CMsgClientRequestForgottenPasswordEmail) GetPasswordTried() string { + if m != nil && m.PasswordTried != nil { + return *m.PasswordTried + } + return "" +} + +type CMsgClientRequestForgottenPasswordEmailResponse struct { + EResult *uint32 `protobuf:"varint,1,opt,name=eResult" json:"eResult,omitempty"` + UseSecretQuestion *bool `protobuf:"varint,2,opt,name=use_secret_question" json:"use_secret_question,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestForgottenPasswordEmailResponse) Reset() { + *m = CMsgClientRequestForgottenPasswordEmailResponse{} +} +func (m *CMsgClientRequestForgottenPasswordEmailResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientRequestForgottenPasswordEmailResponse) ProtoMessage() {} +func (*CMsgClientRequestForgottenPasswordEmailResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{107} +} + +func (m *CMsgClientRequestForgottenPasswordEmailResponse) GetEResult() uint32 { + if m != nil && m.EResult != nil { + return *m.EResult + } + return 0 +} + +func (m *CMsgClientRequestForgottenPasswordEmailResponse) GetUseSecretQuestion() bool { + if m != nil && m.UseSecretQuestion != nil { + return *m.UseSecretQuestion + } + return false +} + +type CMsgClientItemAnnouncements struct { + CountNewItems *uint32 `protobuf:"varint,1,opt,name=count_new_items" json:"count_new_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientItemAnnouncements) Reset() { *m = CMsgClientItemAnnouncements{} } +func (m *CMsgClientItemAnnouncements) String() string { return proto.CompactTextString(m) } +func (*CMsgClientItemAnnouncements) ProtoMessage() {} +func (*CMsgClientItemAnnouncements) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{108} } + +func (m *CMsgClientItemAnnouncements) GetCountNewItems() uint32 { + if m != nil && m.CountNewItems != nil { + return *m.CountNewItems + } + return 0 +} + +type CMsgClientRequestItemAnnouncements struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestItemAnnouncements) Reset() { *m = CMsgClientRequestItemAnnouncements{} } +func (m *CMsgClientRequestItemAnnouncements) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestItemAnnouncements) ProtoMessage() {} +func (*CMsgClientRequestItemAnnouncements) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{109} +} + +type CMsgClientUserNotifications struct { + Notifications []*CMsgClientUserNotifications_Notification `protobuf:"bytes,1,rep,name=notifications" json:"notifications,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUserNotifications) Reset() { *m = CMsgClientUserNotifications{} } +func (m *CMsgClientUserNotifications) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUserNotifications) ProtoMessage() {} +func (*CMsgClientUserNotifications) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{110} } + +func (m *CMsgClientUserNotifications) GetNotifications() []*CMsgClientUserNotifications_Notification { + if m != nil { + return m.Notifications + } + return nil +} + +type CMsgClientUserNotifications_Notification struct { + UserNotificationType *uint32 `protobuf:"varint,1,opt,name=user_notification_type" json:"user_notification_type,omitempty"` + Count *uint32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUserNotifications_Notification) Reset() { + *m = CMsgClientUserNotifications_Notification{} +} +func (m *CMsgClientUserNotifications_Notification) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUserNotifications_Notification) ProtoMessage() {} +func (*CMsgClientUserNotifications_Notification) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{110, 0} +} + +func (m *CMsgClientUserNotifications_Notification) GetUserNotificationType() uint32 { + if m != nil && m.UserNotificationType != nil { + return *m.UserNotificationType + } + return 0 +} + +func (m *CMsgClientUserNotifications_Notification) GetCount() uint32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +type CMsgClientCommentNotifications struct { + CountNewComments *uint32 `protobuf:"varint,1,opt,name=count_new_comments" json:"count_new_comments,omitempty"` + CountNewCommentsOwner *uint32 `protobuf:"varint,2,opt,name=count_new_comments_owner" json:"count_new_comments_owner,omitempty"` + CountNewCommentsSubscriptions *uint32 `protobuf:"varint,3,opt,name=count_new_comments_subscriptions" json:"count_new_comments_subscriptions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCommentNotifications) Reset() { *m = CMsgClientCommentNotifications{} } +func (m *CMsgClientCommentNotifications) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCommentNotifications) ProtoMessage() {} +func (*CMsgClientCommentNotifications) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{111} +} + +func (m *CMsgClientCommentNotifications) GetCountNewComments() uint32 { + if m != nil && m.CountNewComments != nil { + return *m.CountNewComments + } + return 0 +} + +func (m *CMsgClientCommentNotifications) GetCountNewCommentsOwner() uint32 { + if m != nil && m.CountNewCommentsOwner != nil { + return *m.CountNewCommentsOwner + } + return 0 +} + +func (m *CMsgClientCommentNotifications) GetCountNewCommentsSubscriptions() uint32 { + if m != nil && m.CountNewCommentsSubscriptions != nil { + return *m.CountNewCommentsSubscriptions + } + return 0 +} + +type CMsgClientRequestCommentNotifications struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestCommentNotifications) Reset() { *m = CMsgClientRequestCommentNotifications{} } +func (m *CMsgClientRequestCommentNotifications) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestCommentNotifications) ProtoMessage() {} +func (*CMsgClientRequestCommentNotifications) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{112} +} + +type CMsgClientOfflineMessageNotification struct { + OfflineMessages *uint32 `protobuf:"varint,1,opt,name=offline_messages" json:"offline_messages,omitempty"` + FriendsWithOfflineMessages []uint32 `protobuf:"varint,2,rep,name=friends_with_offline_messages" json:"friends_with_offline_messages,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientOfflineMessageNotification) Reset() { *m = CMsgClientOfflineMessageNotification{} } +func (m *CMsgClientOfflineMessageNotification) String() string { return proto.CompactTextString(m) } +func (*CMsgClientOfflineMessageNotification) ProtoMessage() {} +func (*CMsgClientOfflineMessageNotification) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{113} +} + +func (m *CMsgClientOfflineMessageNotification) GetOfflineMessages() uint32 { + if m != nil && m.OfflineMessages != nil { + return *m.OfflineMessages + } + return 0 +} + +func (m *CMsgClientOfflineMessageNotification) GetFriendsWithOfflineMessages() []uint32 { + if m != nil { + return m.FriendsWithOfflineMessages + } + return nil +} + +type CMsgClientRequestOfflineMessageCount struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientRequestOfflineMessageCount) Reset() { *m = CMsgClientRequestOfflineMessageCount{} } +func (m *CMsgClientRequestOfflineMessageCount) String() string { return proto.CompactTextString(m) } +func (*CMsgClientRequestOfflineMessageCount) ProtoMessage() {} +func (*CMsgClientRequestOfflineMessageCount) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{114} +} + +type CMsgClientFSGetFriendMessageHistory struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFSGetFriendMessageHistory) Reset() { *m = CMsgClientFSGetFriendMessageHistory{} } +func (m *CMsgClientFSGetFriendMessageHistory) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFSGetFriendMessageHistory) ProtoMessage() {} +func (*CMsgClientFSGetFriendMessageHistory) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{115} +} + +func (m *CMsgClientFSGetFriendMessageHistory) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CMsgClientFSGetFriendMessageHistoryResponse struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Success *uint32 `protobuf:"varint,2,opt,name=success" json:"success,omitempty"` + Messages []*CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage `protobuf:"bytes,3,rep,name=messages" json:"messages,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse) Reset() { + *m = CMsgClientFSGetFriendMessageHistoryResponse{} +} +func (m *CMsgClientFSGetFriendMessageHistoryResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientFSGetFriendMessageHistoryResponse) ProtoMessage() {} +func (*CMsgClientFSGetFriendMessageHistoryResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{116} +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse) GetSuccess() uint32 { + if m != nil && m.Success != nil { + return *m.Success + } + return 0 +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse) GetMessages() []*CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage { + if m != nil { + return m.Messages + } + return nil +} + +type CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage struct { + Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"` + Timestamp *uint32 `protobuf:"varint,2,opt,name=timestamp" json:"timestamp,omitempty"` + Message *string `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"` + Unread *bool `protobuf:"varint,4,opt,name=unread" json:"unread,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) Reset() { + *m = CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage{} +} +func (m *CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) ProtoMessage() {} +func (*CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{116, 0} +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +func (m *CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage) GetUnread() bool { + if m != nil && m.Unread != nil { + return *m.Unread + } + return false +} + +type CMsgClientFSGetFriendMessageHistoryForOfflineMessages struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFSGetFriendMessageHistoryForOfflineMessages) Reset() { + *m = CMsgClientFSGetFriendMessageHistoryForOfflineMessages{} +} +func (m *CMsgClientFSGetFriendMessageHistoryForOfflineMessages) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientFSGetFriendMessageHistoryForOfflineMessages) ProtoMessage() {} +func (*CMsgClientFSGetFriendMessageHistoryForOfflineMessages) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{117} +} + +type CMsgClientFSGetFriendsSteamLevels struct { + Accountids []uint32 `protobuf:"varint,1,rep,name=accountids" json:"accountids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFSGetFriendsSteamLevels) Reset() { *m = CMsgClientFSGetFriendsSteamLevels{} } +func (m *CMsgClientFSGetFriendsSteamLevels) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFSGetFriendsSteamLevels) ProtoMessage() {} +func (*CMsgClientFSGetFriendsSteamLevels) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{118} +} + +func (m *CMsgClientFSGetFriendsSteamLevels) GetAccountids() []uint32 { + if m != nil { + return m.Accountids + } + return nil +} + +type CMsgClientFSGetFriendsSteamLevelsResponse struct { + Friends []*CMsgClientFSGetFriendsSteamLevelsResponse_Friend `protobuf:"bytes,1,rep,name=friends" json:"friends,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFSGetFriendsSteamLevelsResponse) Reset() { + *m = CMsgClientFSGetFriendsSteamLevelsResponse{} +} +func (m *CMsgClientFSGetFriendsSteamLevelsResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFSGetFriendsSteamLevelsResponse) ProtoMessage() {} +func (*CMsgClientFSGetFriendsSteamLevelsResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{119} +} + +func (m *CMsgClientFSGetFriendsSteamLevelsResponse) GetFriends() []*CMsgClientFSGetFriendsSteamLevelsResponse_Friend { + if m != nil { + return m.Friends + } + return nil +} + +type CMsgClientFSGetFriendsSteamLevelsResponse_Friend struct { + Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"` + Level *uint32 `protobuf:"varint,2,opt,name=level" json:"level,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFSGetFriendsSteamLevelsResponse_Friend) Reset() { + *m = CMsgClientFSGetFriendsSteamLevelsResponse_Friend{} +} +func (m *CMsgClientFSGetFriendsSteamLevelsResponse_Friend) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientFSGetFriendsSteamLevelsResponse_Friend) ProtoMessage() {} +func (*CMsgClientFSGetFriendsSteamLevelsResponse_Friend) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{119, 0} +} + +func (m *CMsgClientFSGetFriendsSteamLevelsResponse_Friend) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +func (m *CMsgClientFSGetFriendsSteamLevelsResponse_Friend) GetLevel() uint32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +type CMsgClientEmailAddrInfo struct { + EmailAddress *string `protobuf:"bytes,1,opt,name=email_address" json:"email_address,omitempty"` + EmailIsValidated *bool `protobuf:"varint,2,opt,name=email_is_validated" json:"email_is_validated,omitempty"` + EmailValidationChanged *bool `protobuf:"varint,3,opt,name=email_validation_changed" json:"email_validation_changed,omitempty"` + CredentialChangeRequiresCode *bool `protobuf:"varint,4,opt,name=credential_change_requires_code" json:"credential_change_requires_code,omitempty"` + PasswordOrSecretqaChangeRequiresCode *bool `protobuf:"varint,5,opt,name=password_or_secretqa_change_requires_code" json:"password_or_secretqa_change_requires_code,omitempty"` + RemindUserAboutEmail *bool `protobuf:"varint,6,opt,name=remind_user_about_email" json:"remind_user_about_email,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientEmailAddrInfo) Reset() { *m = CMsgClientEmailAddrInfo{} } +func (m *CMsgClientEmailAddrInfo) String() string { return proto.CompactTextString(m) } +func (*CMsgClientEmailAddrInfo) ProtoMessage() {} +func (*CMsgClientEmailAddrInfo) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{120} } + +func (m *CMsgClientEmailAddrInfo) GetEmailAddress() string { + if m != nil && m.EmailAddress != nil { + return *m.EmailAddress + } + return "" +} + +func (m *CMsgClientEmailAddrInfo) GetEmailIsValidated() bool { + if m != nil && m.EmailIsValidated != nil { + return *m.EmailIsValidated + } + return false +} + +func (m *CMsgClientEmailAddrInfo) GetEmailValidationChanged() bool { + if m != nil && m.EmailValidationChanged != nil { + return *m.EmailValidationChanged + } + return false +} + +func (m *CMsgClientEmailAddrInfo) GetCredentialChangeRequiresCode() bool { + if m != nil && m.CredentialChangeRequiresCode != nil { + return *m.CredentialChangeRequiresCode + } + return false +} + +func (m *CMsgClientEmailAddrInfo) GetPasswordOrSecretqaChangeRequiresCode() bool { + if m != nil && m.PasswordOrSecretqaChangeRequiresCode != nil { + return *m.PasswordOrSecretqaChangeRequiresCode + } + return false +} + +func (m *CMsgClientEmailAddrInfo) GetRemindUserAboutEmail() bool { + if m != nil && m.RemindUserAboutEmail != nil { + return *m.RemindUserAboutEmail + } + return false +} + +type CMsgCREEnumeratePublishedFiles struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + QueryType *int32 `protobuf:"varint,2,opt,name=query_type" json:"query_type,omitempty"` + StartIndex *uint32 `protobuf:"varint,3,opt,name=start_index" json:"start_index,omitempty"` + Days *uint32 `protobuf:"varint,4,opt,name=days" json:"days,omitempty"` + Count *uint32 `protobuf:"varint,5,opt,name=count" json:"count,omitempty"` + Tags []string `protobuf:"bytes,6,rep,name=tags" json:"tags,omitempty"` + UserTags []string `protobuf:"bytes,7,rep,name=user_tags" json:"user_tags,omitempty"` + MatchingFileType *uint32 `protobuf:"varint,8,opt,name=matching_file_type,def=13" json:"matching_file_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREEnumeratePublishedFiles) Reset() { *m = CMsgCREEnumeratePublishedFiles{} } +func (m *CMsgCREEnumeratePublishedFiles) String() string { return proto.CompactTextString(m) } +func (*CMsgCREEnumeratePublishedFiles) ProtoMessage() {} +func (*CMsgCREEnumeratePublishedFiles) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{121} +} + +const Default_CMsgCREEnumeratePublishedFiles_MatchingFileType uint32 = 13 + +func (m *CMsgCREEnumeratePublishedFiles) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFiles) GetQueryType() int32 { + if m != nil && m.QueryType != nil { + return *m.QueryType + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFiles) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFiles) GetDays() uint32 { + if m != nil && m.Days != nil { + return *m.Days + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFiles) GetCount() uint32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFiles) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *CMsgCREEnumeratePublishedFiles) GetUserTags() []string { + if m != nil { + return m.UserTags + } + return nil +} + +func (m *CMsgCREEnumeratePublishedFiles) GetMatchingFileType() uint32 { + if m != nil && m.MatchingFileType != nil { + return *m.MatchingFileType + } + return Default_CMsgCREEnumeratePublishedFiles_MatchingFileType +} + +type CMsgCREEnumeratePublishedFilesResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PublishedFiles []*CMsgCREEnumeratePublishedFilesResponse_PublishedFileId `protobuf:"bytes,2,rep,name=published_files" json:"published_files,omitempty"` + TotalResults *uint32 `protobuf:"varint,3,opt,name=total_results" json:"total_results,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREEnumeratePublishedFilesResponse) Reset() { + *m = CMsgCREEnumeratePublishedFilesResponse{} +} +func (m *CMsgCREEnumeratePublishedFilesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgCREEnumeratePublishedFilesResponse) ProtoMessage() {} +func (*CMsgCREEnumeratePublishedFilesResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{122} +} + +const Default_CMsgCREEnumeratePublishedFilesResponse_Eresult int32 = 2 + +func (m *CMsgCREEnumeratePublishedFilesResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgCREEnumeratePublishedFilesResponse_Eresult +} + +func (m *CMsgCREEnumeratePublishedFilesResponse) GetPublishedFiles() []*CMsgCREEnumeratePublishedFilesResponse_PublishedFileId { + if m != nil { + return m.PublishedFiles + } + return nil +} + +func (m *CMsgCREEnumeratePublishedFilesResponse) GetTotalResults() uint32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +type CMsgCREEnumeratePublishedFilesResponse_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + VotesFor *int32 `protobuf:"varint,2,opt,name=votes_for" json:"votes_for,omitempty"` + VotesAgainst *int32 `protobuf:"varint,3,opt,name=votes_against" json:"votes_against,omitempty"` + Reports *int32 `protobuf:"varint,4,opt,name=reports" json:"reports,omitempty"` + Score *float32 `protobuf:"fixed32,5,opt,name=score" json:"score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) Reset() { + *m = CMsgCREEnumeratePublishedFilesResponse_PublishedFileId{} +} +func (m *CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) String() string { + return proto.CompactTextString(m) +} +func (*CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) ProtoMessage() {} +func (*CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{122, 0} +} + +func (m *CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) GetVotesFor() int32 { + if m != nil && m.VotesFor != nil { + return *m.VotesFor + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) GetVotesAgainst() int32 { + if m != nil && m.VotesAgainst != nil { + return *m.VotesAgainst + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) GetReports() int32 { + if m != nil && m.Reports != nil { + return *m.Reports + } + return 0 +} + +func (m *CMsgCREEnumeratePublishedFilesResponse_PublishedFileId) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +type CMsgCREItemVoteSummary struct { + PublishedFileIds []*CMsgCREItemVoteSummary_PublishedFileId `protobuf:"bytes,1,rep,name=published_file_ids" json:"published_file_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREItemVoteSummary) Reset() { *m = CMsgCREItemVoteSummary{} } +func (m *CMsgCREItemVoteSummary) String() string { return proto.CompactTextString(m) } +func (*CMsgCREItemVoteSummary) ProtoMessage() {} +func (*CMsgCREItemVoteSummary) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{123} } + +func (m *CMsgCREItemVoteSummary) GetPublishedFileIds() []*CMsgCREItemVoteSummary_PublishedFileId { + if m != nil { + return m.PublishedFileIds + } + return nil +} + +type CMsgCREItemVoteSummary_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREItemVoteSummary_PublishedFileId) Reset() { + *m = CMsgCREItemVoteSummary_PublishedFileId{} +} +func (m *CMsgCREItemVoteSummary_PublishedFileId) String() string { return proto.CompactTextString(m) } +func (*CMsgCREItemVoteSummary_PublishedFileId) ProtoMessage() {} +func (*CMsgCREItemVoteSummary_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{123, 0} +} + +func (m *CMsgCREItemVoteSummary_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +type CMsgCREItemVoteSummaryResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + ItemVoteSummaries []*CMsgCREItemVoteSummaryResponse_ItemVoteSummary `protobuf:"bytes,2,rep,name=item_vote_summaries" json:"item_vote_summaries,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREItemVoteSummaryResponse) Reset() { *m = CMsgCREItemVoteSummaryResponse{} } +func (m *CMsgCREItemVoteSummaryResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgCREItemVoteSummaryResponse) ProtoMessage() {} +func (*CMsgCREItemVoteSummaryResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{124} +} + +const Default_CMsgCREItemVoteSummaryResponse_Eresult int32 = 2 + +func (m *CMsgCREItemVoteSummaryResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgCREItemVoteSummaryResponse_Eresult +} + +func (m *CMsgCREItemVoteSummaryResponse) GetItemVoteSummaries() []*CMsgCREItemVoteSummaryResponse_ItemVoteSummary { + if m != nil { + return m.ItemVoteSummaries + } + return nil +} + +type CMsgCREItemVoteSummaryResponse_ItemVoteSummary struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + VotesFor *int32 `protobuf:"varint,2,opt,name=votes_for" json:"votes_for,omitempty"` + VotesAgainst *int32 `protobuf:"varint,3,opt,name=votes_against" json:"votes_against,omitempty"` + Reports *int32 `protobuf:"varint,4,opt,name=reports" json:"reports,omitempty"` + Score *float32 `protobuf:"fixed32,5,opt,name=score" json:"score,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREItemVoteSummaryResponse_ItemVoteSummary) Reset() { + *m = CMsgCREItemVoteSummaryResponse_ItemVoteSummary{} +} +func (m *CMsgCREItemVoteSummaryResponse_ItemVoteSummary) String() string { + return proto.CompactTextString(m) +} +func (*CMsgCREItemVoteSummaryResponse_ItemVoteSummary) ProtoMessage() {} +func (*CMsgCREItemVoteSummaryResponse_ItemVoteSummary) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{124, 0} +} + +func (m *CMsgCREItemVoteSummaryResponse_ItemVoteSummary) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgCREItemVoteSummaryResponse_ItemVoteSummary) GetVotesFor() int32 { + if m != nil && m.VotesFor != nil { + return *m.VotesFor + } + return 0 +} + +func (m *CMsgCREItemVoteSummaryResponse_ItemVoteSummary) GetVotesAgainst() int32 { + if m != nil && m.VotesAgainst != nil { + return *m.VotesAgainst + } + return 0 +} + +func (m *CMsgCREItemVoteSummaryResponse_ItemVoteSummary) GetReports() int32 { + if m != nil && m.Reports != nil { + return *m.Reports + } + return 0 +} + +func (m *CMsgCREItemVoteSummaryResponse_ItemVoteSummary) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +type CMsgCREUpdateUserPublishedItemVote struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + VoteUp *bool `protobuf:"varint,2,opt,name=vote_up" json:"vote_up,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREUpdateUserPublishedItemVote) Reset() { *m = CMsgCREUpdateUserPublishedItemVote{} } +func (m *CMsgCREUpdateUserPublishedItemVote) String() string { return proto.CompactTextString(m) } +func (*CMsgCREUpdateUserPublishedItemVote) ProtoMessage() {} +func (*CMsgCREUpdateUserPublishedItemVote) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{125} +} + +func (m *CMsgCREUpdateUserPublishedItemVote) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgCREUpdateUserPublishedItemVote) GetVoteUp() bool { + if m != nil && m.VoteUp != nil { + return *m.VoteUp + } + return false +} + +type CMsgCREUpdateUserPublishedItemVoteResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREUpdateUserPublishedItemVoteResponse) Reset() { + *m = CMsgCREUpdateUserPublishedItemVoteResponse{} +} +func (m *CMsgCREUpdateUserPublishedItemVoteResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgCREUpdateUserPublishedItemVoteResponse) ProtoMessage() {} +func (*CMsgCREUpdateUserPublishedItemVoteResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{126} +} + +const Default_CMsgCREUpdateUserPublishedItemVoteResponse_Eresult int32 = 2 + +func (m *CMsgCREUpdateUserPublishedItemVoteResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgCREUpdateUserPublishedItemVoteResponse_Eresult +} + +type CMsgCREGetUserPublishedItemVoteDetails struct { + PublishedFileIds []*CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId `protobuf:"bytes,1,rep,name=published_file_ids" json:"published_file_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREGetUserPublishedItemVoteDetails) Reset() { + *m = CMsgCREGetUserPublishedItemVoteDetails{} +} +func (m *CMsgCREGetUserPublishedItemVoteDetails) String() string { return proto.CompactTextString(m) } +func (*CMsgCREGetUserPublishedItemVoteDetails) ProtoMessage() {} +func (*CMsgCREGetUserPublishedItemVoteDetails) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{127} +} + +func (m *CMsgCREGetUserPublishedItemVoteDetails) GetPublishedFileIds() []*CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId { + if m != nil { + return m.PublishedFileIds + } + return nil +} + +type CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId) Reset() { + *m = CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId{} +} +func (m *CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId) String() string { + return proto.CompactTextString(m) +} +func (*CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId) ProtoMessage() {} +func (*CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{127, 0} +} + +func (m *CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +type CMsgCREGetUserPublishedItemVoteDetailsResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + UserItemVoteDetails []*CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail `protobuf:"bytes,2,rep,name=user_item_vote_details" json:"user_item_vote_details,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse) Reset() { + *m = CMsgCREGetUserPublishedItemVoteDetailsResponse{} +} +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse) String() string { + return proto.CompactTextString(m) +} +func (*CMsgCREGetUserPublishedItemVoteDetailsResponse) ProtoMessage() {} +func (*CMsgCREGetUserPublishedItemVoteDetailsResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{128} +} + +const Default_CMsgCREGetUserPublishedItemVoteDetailsResponse_Eresult int32 = 2 + +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgCREGetUserPublishedItemVoteDetailsResponse_Eresult +} + +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse) GetUserItemVoteDetails() []*CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail { + if m != nil { + return m.UserItemVoteDetails + } + return nil +} + +type CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + Vote *int32 `protobuf:"varint,2,opt,name=vote,def=0" json:"vote,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail) Reset() { + *m = CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail{} +} +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail) String() string { + return proto.CompactTextString(m) +} +func (*CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail) ProtoMessage() {} +func (*CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{128, 0} +} + +const Default_CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail_Vote int32 = 0 + +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail) GetVote() int32 { + if m != nil && m.Vote != nil { + return *m.Vote + } + return Default_CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail_Vote +} + +type CMsgGameServerPingSample struct { + MyIp *uint32 `protobuf:"fixed32,1,opt,name=my_ip" json:"my_ip,omitempty"` + GsAppId *int32 `protobuf:"varint,2,opt,name=gs_app_id" json:"gs_app_id,omitempty"` + GsSamples []*CMsgGameServerPingSample_Sample `protobuf:"bytes,3,rep,name=gs_samples" json:"gs_samples,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGameServerPingSample) Reset() { *m = CMsgGameServerPingSample{} } +func (m *CMsgGameServerPingSample) String() string { return proto.CompactTextString(m) } +func (*CMsgGameServerPingSample) ProtoMessage() {} +func (*CMsgGameServerPingSample) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{129} } + +func (m *CMsgGameServerPingSample) GetMyIp() uint32 { + if m != nil && m.MyIp != nil { + return *m.MyIp + } + return 0 +} + +func (m *CMsgGameServerPingSample) GetGsAppId() int32 { + if m != nil && m.GsAppId != nil { + return *m.GsAppId + } + return 0 +} + +func (m *CMsgGameServerPingSample) GetGsSamples() []*CMsgGameServerPingSample_Sample { + if m != nil { + return m.GsSamples + } + return nil +} + +type CMsgGameServerPingSample_Sample struct { + Ip *uint32 `protobuf:"fixed32,1,opt,name=ip" json:"ip,omitempty"` + AvgPingMs *uint32 `protobuf:"varint,2,opt,name=avg_ping_ms" json:"avg_ping_ms,omitempty"` + StddevPingMsX10 *uint32 `protobuf:"varint,3,opt,name=stddev_ping_ms_x10" json:"stddev_ping_ms_x10,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgGameServerPingSample_Sample) Reset() { *m = CMsgGameServerPingSample_Sample{} } +func (m *CMsgGameServerPingSample_Sample) String() string { return proto.CompactTextString(m) } +func (*CMsgGameServerPingSample_Sample) ProtoMessage() {} +func (*CMsgGameServerPingSample_Sample) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{129, 0} +} + +func (m *CMsgGameServerPingSample_Sample) GetIp() uint32 { + if m != nil && m.Ip != nil { + return *m.Ip + } + return 0 +} + +func (m *CMsgGameServerPingSample_Sample) GetAvgPingMs() uint32 { + if m != nil && m.AvgPingMs != nil { + return *m.AvgPingMs + } + return 0 +} + +func (m *CMsgGameServerPingSample_Sample) GetStddevPingMsX10() uint32 { + if m != nil && m.StddevPingMsX10 != nil { + return *m.StddevPingMsX10 + } + return 0 +} + +type CMsgFSGetFollowerCount struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFSGetFollowerCount) Reset() { *m = CMsgFSGetFollowerCount{} } +func (m *CMsgFSGetFollowerCount) String() string { return proto.CompactTextString(m) } +func (*CMsgFSGetFollowerCount) ProtoMessage() {} +func (*CMsgFSGetFollowerCount) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{130} } + +func (m *CMsgFSGetFollowerCount) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CMsgFSGetFollowerCountResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Count *int32 `protobuf:"varint,2,opt,name=count,def=0" json:"count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFSGetFollowerCountResponse) Reset() { *m = CMsgFSGetFollowerCountResponse{} } +func (m *CMsgFSGetFollowerCountResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgFSGetFollowerCountResponse) ProtoMessage() {} +func (*CMsgFSGetFollowerCountResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{131} +} + +const Default_CMsgFSGetFollowerCountResponse_Eresult int32 = 2 +const Default_CMsgFSGetFollowerCountResponse_Count int32 = 0 + +func (m *CMsgFSGetFollowerCountResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgFSGetFollowerCountResponse_Eresult +} + +func (m *CMsgFSGetFollowerCountResponse) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return Default_CMsgFSGetFollowerCountResponse_Count +} + +type CMsgFSGetIsFollowing struct { + SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id" json:"steam_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFSGetIsFollowing) Reset() { *m = CMsgFSGetIsFollowing{} } +func (m *CMsgFSGetIsFollowing) String() string { return proto.CompactTextString(m) } +func (*CMsgFSGetIsFollowing) ProtoMessage() {} +func (*CMsgFSGetIsFollowing) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{132} } + +func (m *CMsgFSGetIsFollowing) GetSteamId() uint64 { + if m != nil && m.SteamId != nil { + return *m.SteamId + } + return 0 +} + +type CMsgFSGetIsFollowingResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + IsFollowing *bool `protobuf:"varint,2,opt,name=is_following,def=0" json:"is_following,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFSGetIsFollowingResponse) Reset() { *m = CMsgFSGetIsFollowingResponse{} } +func (m *CMsgFSGetIsFollowingResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgFSGetIsFollowingResponse) ProtoMessage() {} +func (*CMsgFSGetIsFollowingResponse) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{133} } + +const Default_CMsgFSGetIsFollowingResponse_Eresult int32 = 2 +const Default_CMsgFSGetIsFollowingResponse_IsFollowing bool = false + +func (m *CMsgFSGetIsFollowingResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgFSGetIsFollowingResponse_Eresult +} + +func (m *CMsgFSGetIsFollowingResponse) GetIsFollowing() bool { + if m != nil && m.IsFollowing != nil { + return *m.IsFollowing + } + return Default_CMsgFSGetIsFollowingResponse_IsFollowing +} + +type CMsgFSEnumerateFollowingList struct { + StartIndex *uint32 `protobuf:"varint,1,opt,name=start_index" json:"start_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFSEnumerateFollowingList) Reset() { *m = CMsgFSEnumerateFollowingList{} } +func (m *CMsgFSEnumerateFollowingList) String() string { return proto.CompactTextString(m) } +func (*CMsgFSEnumerateFollowingList) ProtoMessage() {} +func (*CMsgFSEnumerateFollowingList) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{134} } + +func (m *CMsgFSEnumerateFollowingList) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +type CMsgFSEnumerateFollowingListResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + TotalResults *int32 `protobuf:"varint,2,opt,name=total_results" json:"total_results,omitempty"` + SteamIds []uint64 `protobuf:"fixed64,3,rep,name=steam_ids" json:"steam_ids,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgFSEnumerateFollowingListResponse) Reset() { *m = CMsgFSEnumerateFollowingListResponse{} } +func (m *CMsgFSEnumerateFollowingListResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgFSEnumerateFollowingListResponse) ProtoMessage() {} +func (*CMsgFSEnumerateFollowingListResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{135} +} + +const Default_CMsgFSEnumerateFollowingListResponse_Eresult int32 = 2 + +func (m *CMsgFSEnumerateFollowingListResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgFSEnumerateFollowingListResponse_Eresult +} + +func (m *CMsgFSEnumerateFollowingListResponse) GetTotalResults() int32 { + if m != nil && m.TotalResults != nil { + return *m.TotalResults + } + return 0 +} + +func (m *CMsgFSEnumerateFollowingListResponse) GetSteamIds() []uint64 { + if m != nil { + return m.SteamIds + } + return nil +} + +type CMsgDPGetNumberOfCurrentPlayers struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDPGetNumberOfCurrentPlayers) Reset() { *m = CMsgDPGetNumberOfCurrentPlayers{} } +func (m *CMsgDPGetNumberOfCurrentPlayers) String() string { return proto.CompactTextString(m) } +func (*CMsgDPGetNumberOfCurrentPlayers) ProtoMessage() {} +func (*CMsgDPGetNumberOfCurrentPlayers) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{136} +} + +func (m *CMsgDPGetNumberOfCurrentPlayers) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CMsgDPGetNumberOfCurrentPlayersResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + PlayerCount *int32 `protobuf:"varint,2,opt,name=player_count" json:"player_count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgDPGetNumberOfCurrentPlayersResponse) Reset() { + *m = CMsgDPGetNumberOfCurrentPlayersResponse{} +} +func (m *CMsgDPGetNumberOfCurrentPlayersResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgDPGetNumberOfCurrentPlayersResponse) ProtoMessage() {} +func (*CMsgDPGetNumberOfCurrentPlayersResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{137} +} + +const Default_CMsgDPGetNumberOfCurrentPlayersResponse_Eresult int32 = 2 + +func (m *CMsgDPGetNumberOfCurrentPlayersResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgDPGetNumberOfCurrentPlayersResponse_Eresult +} + +func (m *CMsgDPGetNumberOfCurrentPlayersResponse) GetPlayerCount() int32 { + if m != nil && m.PlayerCount != nil { + return *m.PlayerCount + } + return 0 +} + +type CMsgClientFriendUserStatusPublished struct { + FriendSteamid *uint64 `protobuf:"fixed64,1,opt,name=friend_steamid" json:"friend_steamid,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + StatusText *string `protobuf:"bytes,3,opt,name=status_text" json:"status_text,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientFriendUserStatusPublished) Reset() { *m = CMsgClientFriendUserStatusPublished{} } +func (m *CMsgClientFriendUserStatusPublished) String() string { return proto.CompactTextString(m) } +func (*CMsgClientFriendUserStatusPublished) ProtoMessage() {} +func (*CMsgClientFriendUserStatusPublished) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{138} +} + +func (m *CMsgClientFriendUserStatusPublished) GetFriendSteamid() uint64 { + if m != nil && m.FriendSteamid != nil { + return *m.FriendSteamid + } + return 0 +} + +func (m *CMsgClientFriendUserStatusPublished) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CMsgClientFriendUserStatusPublished) GetStatusText() string { + if m != nil && m.StatusText != nil { + return *m.StatusText + } + return "" +} + +type CMsgClientServiceMethod struct { + MethodName *string `protobuf:"bytes,1,opt,name=method_name" json:"method_name,omitempty"` + SerializedMethod []byte `protobuf:"bytes,2,opt,name=serialized_method" json:"serialized_method,omitempty"` + IsNotification *bool `protobuf:"varint,3,opt,name=is_notification" json:"is_notification,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServiceMethod) Reset() { *m = CMsgClientServiceMethod{} } +func (m *CMsgClientServiceMethod) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServiceMethod) ProtoMessage() {} +func (*CMsgClientServiceMethod) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{139} } + +func (m *CMsgClientServiceMethod) GetMethodName() string { + if m != nil && m.MethodName != nil { + return *m.MethodName + } + return "" +} + +func (m *CMsgClientServiceMethod) GetSerializedMethod() []byte { + if m != nil { + return m.SerializedMethod + } + return nil +} + +func (m *CMsgClientServiceMethod) GetIsNotification() bool { + if m != nil && m.IsNotification != nil { + return *m.IsNotification + } + return false +} + +type CMsgClientServiceMethodResponse struct { + MethodName *string `protobuf:"bytes,1,opt,name=method_name" json:"method_name,omitempty"` + SerializedMethodResponse []byte `protobuf:"bytes,2,opt,name=serialized_method_response" json:"serialized_method_response,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServiceMethodResponse) Reset() { *m = CMsgClientServiceMethodResponse{} } +func (m *CMsgClientServiceMethodResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServiceMethodResponse) ProtoMessage() {} +func (*CMsgClientServiceMethodResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{140} +} + +func (m *CMsgClientServiceMethodResponse) GetMethodName() string { + if m != nil && m.MethodName != nil { + return *m.MethodName + } + return "" +} + +func (m *CMsgClientServiceMethodResponse) GetSerializedMethodResponse() []byte { + if m != nil { + return m.SerializedMethodResponse + } + return nil +} + +type CMsgClientUIMode struct { + Uimode *uint32 `protobuf:"varint,1,opt,name=uimode" json:"uimode,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUIMode) Reset() { *m = CMsgClientUIMode{} } +func (m *CMsgClientUIMode) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUIMode) ProtoMessage() {} +func (*CMsgClientUIMode) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{141} } + +func (m *CMsgClientUIMode) GetUimode() uint32 { + if m != nil && m.Uimode != nil { + return *m.Uimode + } + return 0 +} + +type CMsgClientVanityURLChangedNotification struct { + VanityUrl *string `protobuf:"bytes,1,opt,name=vanity_url" json:"vanity_url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientVanityURLChangedNotification) Reset() { + *m = CMsgClientVanityURLChangedNotification{} +} +func (m *CMsgClientVanityURLChangedNotification) String() string { return proto.CompactTextString(m) } +func (*CMsgClientVanityURLChangedNotification) ProtoMessage() {} +func (*CMsgClientVanityURLChangedNotification) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{142} +} + +func (m *CMsgClientVanityURLChangedNotification) GetVanityUrl() string { + if m != nil && m.VanityUrl != nil { + return *m.VanityUrl + } + return "" +} + +type CMsgClientAuthorizeLocalDeviceRequest struct { + DeviceDescription *string `protobuf:"bytes,1,opt,name=device_description" json:"device_description,omitempty"` + OwnerAccountId *uint32 `protobuf:"varint,2,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAuthorizeLocalDeviceRequest) Reset() { *m = CMsgClientAuthorizeLocalDeviceRequest{} } +func (m *CMsgClientAuthorizeLocalDeviceRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAuthorizeLocalDeviceRequest) ProtoMessage() {} +func (*CMsgClientAuthorizeLocalDeviceRequest) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{143} +} + +func (m *CMsgClientAuthorizeLocalDeviceRequest) GetDeviceDescription() string { + if m != nil && m.DeviceDescription != nil { + return *m.DeviceDescription + } + return "" +} + +func (m *CMsgClientAuthorizeLocalDeviceRequest) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +type CMsgClientAuthorizeLocalDevice struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + OwnerAccountId *uint32 `protobuf:"varint,2,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + AuthedDeviceToken *uint64 `protobuf:"varint,3,opt,name=authed_device_token" json:"authed_device_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientAuthorizeLocalDevice) Reset() { *m = CMsgClientAuthorizeLocalDevice{} } +func (m *CMsgClientAuthorizeLocalDevice) String() string { return proto.CompactTextString(m) } +func (*CMsgClientAuthorizeLocalDevice) ProtoMessage() {} +func (*CMsgClientAuthorizeLocalDevice) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{144} +} + +const Default_CMsgClientAuthorizeLocalDevice_Eresult int32 = 2 + +func (m *CMsgClientAuthorizeLocalDevice) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientAuthorizeLocalDevice_Eresult +} + +func (m *CMsgClientAuthorizeLocalDevice) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgClientAuthorizeLocalDevice) GetAuthedDeviceToken() uint64 { + if m != nil && m.AuthedDeviceToken != nil { + return *m.AuthedDeviceToken + } + return 0 +} + +type CMsgClientDeauthorizeDeviceRequest struct { + DeauthorizationAccountId *uint32 `protobuf:"varint,1,opt,name=deauthorization_account_id" json:"deauthorization_account_id,omitempty"` + DeauthorizationDeviceToken *uint64 `protobuf:"varint,2,opt,name=deauthorization_device_token" json:"deauthorization_device_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDeauthorizeDeviceRequest) Reset() { *m = CMsgClientDeauthorizeDeviceRequest{} } +func (m *CMsgClientDeauthorizeDeviceRequest) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDeauthorizeDeviceRequest) ProtoMessage() {} +func (*CMsgClientDeauthorizeDeviceRequest) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{145} +} + +func (m *CMsgClientDeauthorizeDeviceRequest) GetDeauthorizationAccountId() uint32 { + if m != nil && m.DeauthorizationAccountId != nil { + return *m.DeauthorizationAccountId + } + return 0 +} + +func (m *CMsgClientDeauthorizeDeviceRequest) GetDeauthorizationDeviceToken() uint64 { + if m != nil && m.DeauthorizationDeviceToken != nil { + return *m.DeauthorizationDeviceToken + } + return 0 +} + +type CMsgClientDeauthorizeDevice struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + DeauthorizationAccountId *uint32 `protobuf:"varint,2,opt,name=deauthorization_account_id" json:"deauthorization_account_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientDeauthorizeDevice) Reset() { *m = CMsgClientDeauthorizeDevice{} } +func (m *CMsgClientDeauthorizeDevice) String() string { return proto.CompactTextString(m) } +func (*CMsgClientDeauthorizeDevice) ProtoMessage() {} +func (*CMsgClientDeauthorizeDevice) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{146} } + +const Default_CMsgClientDeauthorizeDevice_Eresult int32 = 2 + +func (m *CMsgClientDeauthorizeDevice) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientDeauthorizeDevice_Eresult +} + +func (m *CMsgClientDeauthorizeDevice) GetDeauthorizationAccountId() uint32 { + if m != nil && m.DeauthorizationAccountId != nil { + return *m.DeauthorizationAccountId + } + return 0 +} + +type CMsgClientUseLocalDeviceAuthorizations struct { + AuthorizationAccountId []uint32 `protobuf:"varint,1,rep,name=authorization_account_id" json:"authorization_account_id,omitempty"` + DeviceTokens []*CMsgClientUseLocalDeviceAuthorizations_DeviceToken `protobuf:"bytes,2,rep,name=device_tokens" json:"device_tokens,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUseLocalDeviceAuthorizations) Reset() { + *m = CMsgClientUseLocalDeviceAuthorizations{} +} +func (m *CMsgClientUseLocalDeviceAuthorizations) String() string { return proto.CompactTextString(m) } +func (*CMsgClientUseLocalDeviceAuthorizations) ProtoMessage() {} +func (*CMsgClientUseLocalDeviceAuthorizations) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{147} +} + +func (m *CMsgClientUseLocalDeviceAuthorizations) GetAuthorizationAccountId() []uint32 { + if m != nil { + return m.AuthorizationAccountId + } + return nil +} + +func (m *CMsgClientUseLocalDeviceAuthorizations) GetDeviceTokens() []*CMsgClientUseLocalDeviceAuthorizations_DeviceToken { + if m != nil { + return m.DeviceTokens + } + return nil +} + +type CMsgClientUseLocalDeviceAuthorizations_DeviceToken struct { + OwnerAccountId *uint32 `protobuf:"varint,1,opt,name=owner_account_id" json:"owner_account_id,omitempty"` + TokenId *uint64 `protobuf:"varint,2,opt,name=token_id" json:"token_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientUseLocalDeviceAuthorizations_DeviceToken) Reset() { + *m = CMsgClientUseLocalDeviceAuthorizations_DeviceToken{} +} +func (m *CMsgClientUseLocalDeviceAuthorizations_DeviceToken) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientUseLocalDeviceAuthorizations_DeviceToken) ProtoMessage() {} +func (*CMsgClientUseLocalDeviceAuthorizations_DeviceToken) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{147, 0} +} + +func (m *CMsgClientUseLocalDeviceAuthorizations_DeviceToken) GetOwnerAccountId() uint32 { + if m != nil && m.OwnerAccountId != nil { + return *m.OwnerAccountId + } + return 0 +} + +func (m *CMsgClientUseLocalDeviceAuthorizations_DeviceToken) GetTokenId() uint64 { + if m != nil && m.TokenId != nil { + return *m.TokenId + } + return 0 +} + +type CMsgClientGetAuthorizedDevices struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAuthorizedDevices) Reset() { *m = CMsgClientGetAuthorizedDevices{} } +func (m *CMsgClientGetAuthorizedDevices) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetAuthorizedDevices) ProtoMessage() {} +func (*CMsgClientGetAuthorizedDevices) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{148} +} + +type CMsgClientGetAuthorizedDevicesResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + AuthorizedDevice []*CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice `protobuf:"bytes,2,rep,name=authorized_device" json:"authorized_device,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAuthorizedDevicesResponse) Reset() { + *m = CMsgClientGetAuthorizedDevicesResponse{} +} +func (m *CMsgClientGetAuthorizedDevicesResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetAuthorizedDevicesResponse) ProtoMessage() {} +func (*CMsgClientGetAuthorizedDevicesResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{149} +} + +const Default_CMsgClientGetAuthorizedDevicesResponse_Eresult int32 = 2 + +func (m *CMsgClientGetAuthorizedDevicesResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientGetAuthorizedDevicesResponse_Eresult +} + +func (m *CMsgClientGetAuthorizedDevicesResponse) GetAuthorizedDevice() []*CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice { + if m != nil { + return m.AuthorizedDevice + } + return nil +} + +type CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice struct { + AuthDeviceToken *uint64 `protobuf:"varint,1,opt,name=auth_device_token" json:"auth_device_token,omitempty"` + DeviceName *string `protobuf:"bytes,2,opt,name=device_name" json:"device_name,omitempty"` + LastAccessTime *uint32 `protobuf:"varint,3,opt,name=last_access_time" json:"last_access_time,omitempty"` + BorrowerId *uint32 `protobuf:"varint,4,opt,name=borrower_id" json:"borrower_id,omitempty"` + IsPending *bool `protobuf:"varint,5,opt,name=is_pending" json:"is_pending,omitempty"` + AppPlayed *uint32 `protobuf:"varint,6,opt,name=app_played" json:"app_played,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) Reset() { + *m = CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice{} +} +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) ProtoMessage() {} +func (*CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{149, 0} +} + +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) GetAuthDeviceToken() uint64 { + if m != nil && m.AuthDeviceToken != nil { + return *m.AuthDeviceToken + } + return 0 +} + +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) GetDeviceName() string { + if m != nil && m.DeviceName != nil { + return *m.DeviceName + } + return "" +} + +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) GetLastAccessTime() uint32 { + if m != nil && m.LastAccessTime != nil { + return *m.LastAccessTime + } + return 0 +} + +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) GetBorrowerId() uint32 { + if m != nil && m.BorrowerId != nil { + return *m.BorrowerId + } + return 0 +} + +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) GetIsPending() bool { + if m != nil && m.IsPending != nil { + return *m.IsPending + } + return false +} + +func (m *CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice) GetAppPlayed() uint32 { + if m != nil && m.AppPlayed != nil { + return *m.AppPlayed + } + return 0 +} + +type CMsgClientGetEmoticonList struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientGetEmoticonList) Reset() { *m = CMsgClientGetEmoticonList{} } +func (m *CMsgClientGetEmoticonList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientGetEmoticonList) ProtoMessage() {} +func (*CMsgClientGetEmoticonList) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{150} } + +type CMsgClientEmoticonList struct { + Emoticons []*CMsgClientEmoticonList_Emoticon `protobuf:"bytes,1,rep,name=emoticons" json:"emoticons,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientEmoticonList) Reset() { *m = CMsgClientEmoticonList{} } +func (m *CMsgClientEmoticonList) String() string { return proto.CompactTextString(m) } +func (*CMsgClientEmoticonList) ProtoMessage() {} +func (*CMsgClientEmoticonList) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{151} } + +func (m *CMsgClientEmoticonList) GetEmoticons() []*CMsgClientEmoticonList_Emoticon { + if m != nil { + return m.Emoticons + } + return nil +} + +type CMsgClientEmoticonList_Emoticon struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Count *int32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientEmoticonList_Emoticon) Reset() { *m = CMsgClientEmoticonList_Emoticon{} } +func (m *CMsgClientEmoticonList_Emoticon) String() string { return proto.CompactTextString(m) } +func (*CMsgClientEmoticonList_Emoticon) ProtoMessage() {} +func (*CMsgClientEmoticonList_Emoticon) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{151, 0} +} + +func (m *CMsgClientEmoticonList_Emoticon) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CMsgClientEmoticonList_Emoticon) GetCount() int32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +type CMsgClientSharedLibraryLockStatus struct { + LockedLibrary []*CMsgClientSharedLibraryLockStatus_LockedLibrary `protobuf:"bytes,1,rep,name=locked_library" json:"locked_library,omitempty"` + OwnLibraryLockedBy *uint32 `protobuf:"varint,2,opt,name=own_library_locked_by" json:"own_library_locked_by,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSharedLibraryLockStatus) Reset() { *m = CMsgClientSharedLibraryLockStatus{} } +func (m *CMsgClientSharedLibraryLockStatus) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSharedLibraryLockStatus) ProtoMessage() {} +func (*CMsgClientSharedLibraryLockStatus) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{152} +} + +func (m *CMsgClientSharedLibraryLockStatus) GetLockedLibrary() []*CMsgClientSharedLibraryLockStatus_LockedLibrary { + if m != nil { + return m.LockedLibrary + } + return nil +} + +func (m *CMsgClientSharedLibraryLockStatus) GetOwnLibraryLockedBy() uint32 { + if m != nil && m.OwnLibraryLockedBy != nil { + return *m.OwnLibraryLockedBy + } + return 0 +} + +type CMsgClientSharedLibraryLockStatus_LockedLibrary struct { + OwnerId *uint32 `protobuf:"varint,1,opt,name=owner_id" json:"owner_id,omitempty"` + LockedBy *uint32 `protobuf:"varint,2,opt,name=locked_by" json:"locked_by,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSharedLibraryLockStatus_LockedLibrary) Reset() { + *m = CMsgClientSharedLibraryLockStatus_LockedLibrary{} +} +func (m *CMsgClientSharedLibraryLockStatus_LockedLibrary) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientSharedLibraryLockStatus_LockedLibrary) ProtoMessage() {} +func (*CMsgClientSharedLibraryLockStatus_LockedLibrary) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{152, 0} +} + +func (m *CMsgClientSharedLibraryLockStatus_LockedLibrary) GetOwnerId() uint32 { + if m != nil && m.OwnerId != nil { + return *m.OwnerId + } + return 0 +} + +func (m *CMsgClientSharedLibraryLockStatus_LockedLibrary) GetLockedBy() uint32 { + if m != nil && m.LockedBy != nil { + return *m.LockedBy + } + return 0 +} + +type CMsgClientSharedLibraryStopPlaying struct { + SecondsLeft *int32 `protobuf:"varint,1,opt,name=seconds_left" json:"seconds_left,omitempty"` + StopApps []*CMsgClientSharedLibraryStopPlaying_StopApp `protobuf:"bytes,2,rep,name=stop_apps" json:"stop_apps,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSharedLibraryStopPlaying) Reset() { *m = CMsgClientSharedLibraryStopPlaying{} } +func (m *CMsgClientSharedLibraryStopPlaying) String() string { return proto.CompactTextString(m) } +func (*CMsgClientSharedLibraryStopPlaying) ProtoMessage() {} +func (*CMsgClientSharedLibraryStopPlaying) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{153} +} + +func (m *CMsgClientSharedLibraryStopPlaying) GetSecondsLeft() int32 { + if m != nil && m.SecondsLeft != nil { + return *m.SecondsLeft + } + return 0 +} + +func (m *CMsgClientSharedLibraryStopPlaying) GetStopApps() []*CMsgClientSharedLibraryStopPlaying_StopApp { + if m != nil { + return m.StopApps + } + return nil +} + +type CMsgClientSharedLibraryStopPlaying_StopApp struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + OwnerId *uint32 `protobuf:"varint,2,opt,name=owner_id" json:"owner_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientSharedLibraryStopPlaying_StopApp) Reset() { + *m = CMsgClientSharedLibraryStopPlaying_StopApp{} +} +func (m *CMsgClientSharedLibraryStopPlaying_StopApp) String() string { + return proto.CompactTextString(m) +} +func (*CMsgClientSharedLibraryStopPlaying_StopApp) ProtoMessage() {} +func (*CMsgClientSharedLibraryStopPlaying_StopApp) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{153, 0} +} + +func (m *CMsgClientSharedLibraryStopPlaying_StopApp) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CMsgClientSharedLibraryStopPlaying_StopApp) GetOwnerId() uint32 { + if m != nil && m.OwnerId != nil { + return *m.OwnerId + } + return 0 +} + +type CMsgClientServiceCall struct { + SysidRouting []byte `protobuf:"bytes,1,opt,name=sysid_routing" json:"sysid_routing,omitempty"` + CallHandle *uint32 `protobuf:"varint,2,opt,name=call_handle" json:"call_handle,omitempty"` + ModuleCrc *uint32 `protobuf:"varint,3,opt,name=module_crc" json:"module_crc,omitempty"` + ModuleHash []byte `protobuf:"bytes,4,opt,name=module_hash" json:"module_hash,omitempty"` + FunctionId *uint32 `protobuf:"varint,5,opt,name=function_id" json:"function_id,omitempty"` + CubOutputMax *uint32 `protobuf:"varint,6,opt,name=cub_output_max" json:"cub_output_max,omitempty"` + Flags *uint32 `protobuf:"varint,7,opt,name=flags" json:"flags,omitempty"` + Callparameter []byte `protobuf:"bytes,8,opt,name=callparameter" json:"callparameter,omitempty"` + PingOnly *bool `protobuf:"varint,9,opt,name=ping_only" json:"ping_only,omitempty"` + MaxOutstandingCalls *uint32 `protobuf:"varint,10,opt,name=max_outstanding_calls" json:"max_outstanding_calls,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServiceCall) Reset() { *m = CMsgClientServiceCall{} } +func (m *CMsgClientServiceCall) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServiceCall) ProtoMessage() {} +func (*CMsgClientServiceCall) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{154} } + +func (m *CMsgClientServiceCall) GetSysidRouting() []byte { + if m != nil { + return m.SysidRouting + } + return nil +} + +func (m *CMsgClientServiceCall) GetCallHandle() uint32 { + if m != nil && m.CallHandle != nil { + return *m.CallHandle + } + return 0 +} + +func (m *CMsgClientServiceCall) GetModuleCrc() uint32 { + if m != nil && m.ModuleCrc != nil { + return *m.ModuleCrc + } + return 0 +} + +func (m *CMsgClientServiceCall) GetModuleHash() []byte { + if m != nil { + return m.ModuleHash + } + return nil +} + +func (m *CMsgClientServiceCall) GetFunctionId() uint32 { + if m != nil && m.FunctionId != nil { + return *m.FunctionId + } + return 0 +} + +func (m *CMsgClientServiceCall) GetCubOutputMax() uint32 { + if m != nil && m.CubOutputMax != nil { + return *m.CubOutputMax + } + return 0 +} + +func (m *CMsgClientServiceCall) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *CMsgClientServiceCall) GetCallparameter() []byte { + if m != nil { + return m.Callparameter + } + return nil +} + +func (m *CMsgClientServiceCall) GetPingOnly() bool { + if m != nil && m.PingOnly != nil { + return *m.PingOnly + } + return false +} + +func (m *CMsgClientServiceCall) GetMaxOutstandingCalls() uint32 { + if m != nil && m.MaxOutstandingCalls != nil { + return *m.MaxOutstandingCalls + } + return 0 +} + +type CMsgClientServiceModule struct { + ModuleCrc *uint32 `protobuf:"varint,1,opt,name=module_crc" json:"module_crc,omitempty"` + ModuleHash []byte `protobuf:"bytes,2,opt,name=module_hash" json:"module_hash,omitempty"` + ModuleContent []byte `protobuf:"bytes,3,opt,name=module_content" json:"module_content,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServiceModule) Reset() { *m = CMsgClientServiceModule{} } +func (m *CMsgClientServiceModule) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServiceModule) ProtoMessage() {} +func (*CMsgClientServiceModule) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{155} } + +func (m *CMsgClientServiceModule) GetModuleCrc() uint32 { + if m != nil && m.ModuleCrc != nil { + return *m.ModuleCrc + } + return 0 +} + +func (m *CMsgClientServiceModule) GetModuleHash() []byte { + if m != nil { + return m.ModuleHash + } + return nil +} + +func (m *CMsgClientServiceModule) GetModuleContent() []byte { + if m != nil { + return m.ModuleContent + } + return nil +} + +type CMsgClientServiceCallResponse struct { + SysidRouting []byte `protobuf:"bytes,1,opt,name=sysid_routing" json:"sysid_routing,omitempty"` + CallHandle *uint32 `protobuf:"varint,2,opt,name=call_handle" json:"call_handle,omitempty"` + ModuleCrc *uint32 `protobuf:"varint,3,opt,name=module_crc" json:"module_crc,omitempty"` + ModuleHash []byte `protobuf:"bytes,4,opt,name=module_hash" json:"module_hash,omitempty"` + Ecallresult *uint32 `protobuf:"varint,5,opt,name=ecallresult" json:"ecallresult,omitempty"` + ResultContent []byte `protobuf:"bytes,6,opt,name=result_content" json:"result_content,omitempty"` + OsVersionInfo []byte `protobuf:"bytes,7,opt,name=os_version_info" json:"os_version_info,omitempty"` + SystemInfo []byte `protobuf:"bytes,8,opt,name=system_info" json:"system_info,omitempty"` + LoadAddress *uint64 `protobuf:"fixed64,9,opt,name=load_address" json:"load_address,omitempty"` + ExceptionRecord []byte `protobuf:"bytes,10,opt,name=exception_record" json:"exception_record,omitempty"` + PortableOsVersionInfo []byte `protobuf:"bytes,11,opt,name=portable_os_version_info" json:"portable_os_version_info,omitempty"` + PortableSystemInfo []byte `protobuf:"bytes,12,opt,name=portable_system_info" json:"portable_system_info,omitempty"` + WasConverted *bool `protobuf:"varint,13,opt,name=was_converted" json:"was_converted,omitempty"` + InternalResult *uint32 `protobuf:"varint,14,opt,name=internal_result" json:"internal_result,omitempty"` + CurrentCount *uint32 `protobuf:"varint,15,opt,name=current_count" json:"current_count,omitempty"` + LastCallHandle *uint32 `protobuf:"varint,16,opt,name=last_call_handle" json:"last_call_handle,omitempty"` + LastCallModuleCrc *uint32 `protobuf:"varint,17,opt,name=last_call_module_crc" json:"last_call_module_crc,omitempty"` + LastCallSysidRouting []byte `protobuf:"bytes,18,opt,name=last_call_sysid_routing" json:"last_call_sysid_routing,omitempty"` + LastEcallresult *uint32 `protobuf:"varint,19,opt,name=last_ecallresult" json:"last_ecallresult,omitempty"` + LastCallissueDelta *uint32 `protobuf:"varint,20,opt,name=last_callissue_delta" json:"last_callissue_delta,omitempty"` + LastCallcompleteDelta *uint32 `protobuf:"varint,21,opt,name=last_callcomplete_delta" json:"last_callcomplete_delta,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientServiceCallResponse) Reset() { *m = CMsgClientServiceCallResponse{} } +func (m *CMsgClientServiceCallResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientServiceCallResponse) ProtoMessage() {} +func (*CMsgClientServiceCallResponse) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{156} } + +func (m *CMsgClientServiceCallResponse) GetSysidRouting() []byte { + if m != nil { + return m.SysidRouting + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetCallHandle() uint32 { + if m != nil && m.CallHandle != nil { + return *m.CallHandle + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetModuleCrc() uint32 { + if m != nil && m.ModuleCrc != nil { + return *m.ModuleCrc + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetModuleHash() []byte { + if m != nil { + return m.ModuleHash + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetEcallresult() uint32 { + if m != nil && m.Ecallresult != nil { + return *m.Ecallresult + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetResultContent() []byte { + if m != nil { + return m.ResultContent + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetOsVersionInfo() []byte { + if m != nil { + return m.OsVersionInfo + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetSystemInfo() []byte { + if m != nil { + return m.SystemInfo + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetLoadAddress() uint64 { + if m != nil && m.LoadAddress != nil { + return *m.LoadAddress + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetExceptionRecord() []byte { + if m != nil { + return m.ExceptionRecord + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetPortableOsVersionInfo() []byte { + if m != nil { + return m.PortableOsVersionInfo + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetPortableSystemInfo() []byte { + if m != nil { + return m.PortableSystemInfo + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetWasConverted() bool { + if m != nil && m.WasConverted != nil { + return *m.WasConverted + } + return false +} + +func (m *CMsgClientServiceCallResponse) GetInternalResult() uint32 { + if m != nil && m.InternalResult != nil { + return *m.InternalResult + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetCurrentCount() uint32 { + if m != nil && m.CurrentCount != nil { + return *m.CurrentCount + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetLastCallHandle() uint32 { + if m != nil && m.LastCallHandle != nil { + return *m.LastCallHandle + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetLastCallModuleCrc() uint32 { + if m != nil && m.LastCallModuleCrc != nil { + return *m.LastCallModuleCrc + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetLastCallSysidRouting() []byte { + if m != nil { + return m.LastCallSysidRouting + } + return nil +} + +func (m *CMsgClientServiceCallResponse) GetLastEcallresult() uint32 { + if m != nil && m.LastEcallresult != nil { + return *m.LastEcallresult + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetLastCallissueDelta() uint32 { + if m != nil && m.LastCallissueDelta != nil { + return *m.LastCallissueDelta + } + return 0 +} + +func (m *CMsgClientServiceCallResponse) GetLastCallcompleteDelta() uint32 { + if m != nil && m.LastCallcompleteDelta != nil { + return *m.LastCallcompleteDelta + } + return 0 +} + +type CMsgAMUnlockStreaming struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAMUnlockStreaming) Reset() { *m = CMsgAMUnlockStreaming{} } +func (m *CMsgAMUnlockStreaming) String() string { return proto.CompactTextString(m) } +func (*CMsgAMUnlockStreaming) ProtoMessage() {} +func (*CMsgAMUnlockStreaming) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{157} } + +type CMsgAMUnlockStreamingResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + EncryptionKey []byte `protobuf:"bytes,2,opt,name=encryption_key" json:"encryption_key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgAMUnlockStreamingResponse) Reset() { *m = CMsgAMUnlockStreamingResponse{} } +func (m *CMsgAMUnlockStreamingResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgAMUnlockStreamingResponse) ProtoMessage() {} +func (*CMsgAMUnlockStreamingResponse) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{158} } + +const Default_CMsgAMUnlockStreamingResponse_Eresult int32 = 2 + +func (m *CMsgAMUnlockStreamingResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgAMUnlockStreamingResponse_Eresult +} + +func (m *CMsgAMUnlockStreamingResponse) GetEncryptionKey() []byte { + if m != nil { + return m.EncryptionKey + } + return nil +} + +type CMsgClientPlayingSessionState struct { + PlayingBlocked *bool `protobuf:"varint,2,opt,name=playing_blocked" json:"playing_blocked,omitempty"` + PlayingApp *uint32 `protobuf:"varint,3,opt,name=playing_app" json:"playing_app,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientPlayingSessionState) Reset() { *m = CMsgClientPlayingSessionState{} } +func (m *CMsgClientPlayingSessionState) String() string { return proto.CompactTextString(m) } +func (*CMsgClientPlayingSessionState) ProtoMessage() {} +func (*CMsgClientPlayingSessionState) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{159} } + +func (m *CMsgClientPlayingSessionState) GetPlayingBlocked() bool { + if m != nil && m.PlayingBlocked != nil { + return *m.PlayingBlocked + } + return false +} + +func (m *CMsgClientPlayingSessionState) GetPlayingApp() uint32 { + if m != nil && m.PlayingApp != nil { + return *m.PlayingApp + } + return 0 +} + +type CMsgClientKickPlayingSession struct { + OnlyStopGame *bool `protobuf:"varint,1,opt,name=only_stop_game" json:"only_stop_game,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientKickPlayingSession) Reset() { *m = CMsgClientKickPlayingSession{} } +func (m *CMsgClientKickPlayingSession) String() string { return proto.CompactTextString(m) } +func (*CMsgClientKickPlayingSession) ProtoMessage() {} +func (*CMsgClientKickPlayingSession) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{160} } + +func (m *CMsgClientKickPlayingSession) GetOnlyStopGame() bool { + if m != nil && m.OnlyStopGame != nil { + return *m.OnlyStopGame + } + return false +} + +type CMsgClientCreateAccount struct { + AccountName *string `protobuf:"bytes,1,opt,name=account_name" json:"account_name,omitempty"` + Password *string `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"` + Email *string `protobuf:"bytes,3,opt,name=email" json:"email,omitempty"` + Launcher *uint32 `protobuf:"varint,6,opt,name=launcher" json:"launcher,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCreateAccount) Reset() { *m = CMsgClientCreateAccount{} } +func (m *CMsgClientCreateAccount) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCreateAccount) ProtoMessage() {} +func (*CMsgClientCreateAccount) Descriptor() ([]byte, []int) { return client_server_2_fileDescriptor0, []int{161} } + +func (m *CMsgClientCreateAccount) GetAccountName() string { + if m != nil && m.AccountName != nil { + return *m.AccountName + } + return "" +} + +func (m *CMsgClientCreateAccount) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CMsgClientCreateAccount) GetEmail() string { + if m != nil && m.Email != nil { + return *m.Email + } + return "" +} + +func (m *CMsgClientCreateAccount) GetLauncher() uint32 { + if m != nil && m.Launcher != nil { + return *m.Launcher + } + return 0 +} + +type CMsgClientCreateAccountResponse struct { + Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"` + Steamid *uint64 `protobuf:"fixed64,2,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientCreateAccountResponse) Reset() { *m = CMsgClientCreateAccountResponse{} } +func (m *CMsgClientCreateAccountResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientCreateAccountResponse) ProtoMessage() {} +func (*CMsgClientCreateAccountResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{162} +} + +const Default_CMsgClientCreateAccountResponse_Eresult int32 = 2 + +func (m *CMsgClientCreateAccountResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientCreateAccountResponse_Eresult +} + +func (m *CMsgClientCreateAccountResponse) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CMsgClientVoiceCallPreAuthorize struct { + CallerSteamid *uint64 `protobuf:"fixed64,1,opt,name=caller_steamid" json:"caller_steamid,omitempty"` + ReceiverSteamid *uint64 `protobuf:"fixed64,2,opt,name=receiver_steamid" json:"receiver_steamid,omitempty"` + CallerId *int32 `protobuf:"varint,3,opt,name=caller_id" json:"caller_id,omitempty"` + Hangup *bool `protobuf:"varint,4,opt,name=hangup" json:"hangup,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientVoiceCallPreAuthorize) Reset() { *m = CMsgClientVoiceCallPreAuthorize{} } +func (m *CMsgClientVoiceCallPreAuthorize) String() string { return proto.CompactTextString(m) } +func (*CMsgClientVoiceCallPreAuthorize) ProtoMessage() {} +func (*CMsgClientVoiceCallPreAuthorize) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{163} +} + +func (m *CMsgClientVoiceCallPreAuthorize) GetCallerSteamid() uint64 { + if m != nil && m.CallerSteamid != nil { + return *m.CallerSteamid + } + return 0 +} + +func (m *CMsgClientVoiceCallPreAuthorize) GetReceiverSteamid() uint64 { + if m != nil && m.ReceiverSteamid != nil { + return *m.ReceiverSteamid + } + return 0 +} + +func (m *CMsgClientVoiceCallPreAuthorize) GetCallerId() int32 { + if m != nil && m.CallerId != nil { + return *m.CallerId + } + return 0 +} + +func (m *CMsgClientVoiceCallPreAuthorize) GetHangup() bool { + if m != nil && m.Hangup != nil { + return *m.Hangup + } + return false +} + +type CMsgClientVoiceCallPreAuthorizeResponse struct { + CallerSteamid *uint64 `protobuf:"fixed64,1,opt,name=caller_steamid" json:"caller_steamid,omitempty"` + ReceiverSteamid *uint64 `protobuf:"fixed64,2,opt,name=receiver_steamid" json:"receiver_steamid,omitempty"` + Eresult *int32 `protobuf:"varint,3,opt,name=eresult,def=2" json:"eresult,omitempty"` + CallerId *int32 `protobuf:"varint,4,opt,name=caller_id" json:"caller_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CMsgClientVoiceCallPreAuthorizeResponse) Reset() { + *m = CMsgClientVoiceCallPreAuthorizeResponse{} +} +func (m *CMsgClientVoiceCallPreAuthorizeResponse) String() string { return proto.CompactTextString(m) } +func (*CMsgClientVoiceCallPreAuthorizeResponse) ProtoMessage() {} +func (*CMsgClientVoiceCallPreAuthorizeResponse) Descriptor() ([]byte, []int) { + return client_server_2_fileDescriptor0, []int{164} +} + +const Default_CMsgClientVoiceCallPreAuthorizeResponse_Eresult int32 = 2 + +func (m *CMsgClientVoiceCallPreAuthorizeResponse) GetCallerSteamid() uint64 { + if m != nil && m.CallerSteamid != nil { + return *m.CallerSteamid + } + return 0 +} + +func (m *CMsgClientVoiceCallPreAuthorizeResponse) GetReceiverSteamid() uint64 { + if m != nil && m.ReceiverSteamid != nil { + return *m.ReceiverSteamid + } + return 0 +} + +func (m *CMsgClientVoiceCallPreAuthorizeResponse) GetEresult() int32 { + if m != nil && m.Eresult != nil { + return *m.Eresult + } + return Default_CMsgClientVoiceCallPreAuthorizeResponse_Eresult +} + +func (m *CMsgClientVoiceCallPreAuthorizeResponse) GetCallerId() int32 { + if m != nil && m.CallerId != nil { + return *m.CallerId + } + return 0 +} + +func init() { + proto.RegisterType((*CMsgClientUCMAddScreenshot)(nil), "CMsgClientUCMAddScreenshot") + proto.RegisterType((*CMsgClientUCMAddScreenshot_Tag)(nil), "CMsgClientUCMAddScreenshot.Tag") + proto.RegisterType((*CMsgClientUCMAddScreenshotResponse)(nil), "CMsgClientUCMAddScreenshotResponse") + proto.RegisterType((*CMsgClientUCMDeleteScreenshot)(nil), "CMsgClientUCMDeleteScreenshot") + proto.RegisterType((*CMsgClientUCMDeleteScreenshotResponse)(nil), "CMsgClientUCMDeleteScreenshotResponse") + proto.RegisterType((*CMsgClientUCMPublishFile)(nil), "CMsgClientUCMPublishFile") + proto.RegisterType((*CMsgClientUCMPublishFileResponse)(nil), "CMsgClientUCMPublishFileResponse") + proto.RegisterType((*CMsgClientUCMUpdatePublishedFile)(nil), "CMsgClientUCMUpdatePublishedFile") + proto.RegisterType((*CMsgClientUCMUpdatePublishedFile_KeyValueTag)(nil), "CMsgClientUCMUpdatePublishedFile.KeyValueTag") + proto.RegisterType((*CMsgClientUCMUpdatePublishedFileResponse)(nil), "CMsgClientUCMUpdatePublishedFileResponse") + proto.RegisterType((*CMsgClientUCMDeletePublishedFile)(nil), "CMsgClientUCMDeletePublishedFile") + proto.RegisterType((*CMsgClientUCMDeletePublishedFileResponse)(nil), "CMsgClientUCMDeletePublishedFileResponse") + proto.RegisterType((*CMsgClientUCMEnumerateUserPublishedFiles)(nil), "CMsgClientUCMEnumerateUserPublishedFiles") + proto.RegisterType((*CMsgClientUCMEnumerateUserPublishedFilesResponse)(nil), "CMsgClientUCMEnumerateUserPublishedFilesResponse") + proto.RegisterType((*CMsgClientUCMEnumerateUserPublishedFilesResponse_PublishedFileId)(nil), "CMsgClientUCMEnumerateUserPublishedFilesResponse.PublishedFileId") + proto.RegisterType((*CMsgClientUCMEnumerateUserSubscribedFiles)(nil), "CMsgClientUCMEnumerateUserSubscribedFiles") + proto.RegisterType((*CMsgClientUCMEnumerateUserSubscribedFilesResponse)(nil), "CMsgClientUCMEnumerateUserSubscribedFilesResponse") + proto.RegisterType((*CMsgClientUCMEnumerateUserSubscribedFilesResponse_PublishedFileId)(nil), "CMsgClientUCMEnumerateUserSubscribedFilesResponse.PublishedFileId") + proto.RegisterType((*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates)(nil), "CMsgClientUCMEnumerateUserSubscribedFilesWithUpdates") + proto.RegisterType((*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse)(nil), "CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse") + proto.RegisterType((*CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse_PublishedFileId)(nil), "CMsgClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse.PublishedFileId") + proto.RegisterType((*CMsgClientUCMPublishedFileSubscribed)(nil), "CMsgClientUCMPublishedFileSubscribed") + proto.RegisterType((*CMsgClientUCMPublishedFileUnsubscribed)(nil), "CMsgClientUCMPublishedFileUnsubscribed") + proto.RegisterType((*CMsgClientUCMPublishedFileDeleted)(nil), "CMsgClientUCMPublishedFileDeleted") + proto.RegisterType((*CMsgClientUCMPublishedFileUpdated)(nil), "CMsgClientUCMPublishedFileUpdated") + proto.RegisterType((*CMsgClientWorkshopItemChangesRequest)(nil), "CMsgClientWorkshopItemChangesRequest") + proto.RegisterType((*CMsgClientWorkshopItemChangesResponse)(nil), "CMsgClientWorkshopItemChangesResponse") + proto.RegisterType((*CMsgClientWorkshopItemChangesResponse_WorkshopItemInfo)(nil), "CMsgClientWorkshopItemChangesResponse.WorkshopItemInfo") + proto.RegisterType((*CMsgClientWorkshopItemInfoRequest)(nil), "CMsgClientWorkshopItemInfoRequest") + proto.RegisterType((*CMsgClientWorkshopItemInfoRequest_WorkshopItem)(nil), "CMsgClientWorkshopItemInfoRequest.WorkshopItem") + proto.RegisterType((*CMsgClientWorkshopItemInfoResponse)(nil), "CMsgClientWorkshopItemInfoResponse") + proto.RegisterType((*CMsgClientWorkshopItemInfoResponse_WorkshopItemInfo)(nil), "CMsgClientWorkshopItemInfoResponse.WorkshopItemInfo") + proto.RegisterType((*CMsgClientUCMGetPublishedFilesForUser)(nil), "CMsgClientUCMGetPublishedFilesForUser") + proto.RegisterType((*CMsgClientUCMGetPublishedFilesForUserResponse)(nil), "CMsgClientUCMGetPublishedFilesForUserResponse") + proto.RegisterType((*CMsgClientUCMGetPublishedFilesForUserResponse_PublishedFileId)(nil), "CMsgClientUCMGetPublishedFilesForUserResponse.PublishedFileId") + proto.RegisterType((*CMsgClientUCMSetUserPublishedFileAction)(nil), "CMsgClientUCMSetUserPublishedFileAction") + proto.RegisterType((*CMsgClientUCMSetUserPublishedFileActionResponse)(nil), "CMsgClientUCMSetUserPublishedFileActionResponse") + proto.RegisterType((*CMsgClientUCMEnumeratePublishedFilesByUserAction)(nil), "CMsgClientUCMEnumeratePublishedFilesByUserAction") + proto.RegisterType((*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse)(nil), "CMsgClientUCMEnumeratePublishedFilesByUserActionResponse") + proto.RegisterType((*CMsgClientUCMEnumeratePublishedFilesByUserActionResponse_PublishedFileId)(nil), "CMsgClientUCMEnumeratePublishedFilesByUserActionResponse.PublishedFileId") + proto.RegisterType((*CMsgClientScreenshotsChanged)(nil), "CMsgClientScreenshotsChanged") + proto.RegisterType((*CMsgClientUpdateUserGameInfo)(nil), "CMsgClientUpdateUserGameInfo") + proto.RegisterType((*CMsgClientRichPresenceUpload)(nil), "CMsgClientRichPresenceUpload") + proto.RegisterType((*CMsgClientRichPresenceRequest)(nil), "CMsgClientRichPresenceRequest") + proto.RegisterType((*CMsgClientRichPresenceInfo)(nil), "CMsgClientRichPresenceInfo") + proto.RegisterType((*CMsgClientRichPresenceInfo_RichPresence)(nil), "CMsgClientRichPresenceInfo.RichPresence") + proto.RegisterType((*CMsgClientCheckFileSignature)(nil), "CMsgClientCheckFileSignature") + proto.RegisterType((*CMsgClientCheckFileSignatureResponse)(nil), "CMsgClientCheckFileSignatureResponse") + proto.RegisterType((*CMsgClientReadMachineAuth)(nil), "CMsgClientReadMachineAuth") + proto.RegisterType((*CMsgClientReadMachineAuthResponse)(nil), "CMsgClientReadMachineAuthResponse") + proto.RegisterType((*CMsgClientUpdateMachineAuth)(nil), "CMsgClientUpdateMachineAuth") + proto.RegisterType((*CMsgClientUpdateMachineAuthResponse)(nil), "CMsgClientUpdateMachineAuthResponse") + proto.RegisterType((*CMsgClientRequestMachineAuth)(nil), "CMsgClientRequestMachineAuth") + proto.RegisterType((*CMsgClientRequestMachineAuthResponse)(nil), "CMsgClientRequestMachineAuthResponse") + proto.RegisterType((*CMsgClientCreateFriendsGroup)(nil), "CMsgClientCreateFriendsGroup") + proto.RegisterType((*CMsgClientCreateFriendsGroupResponse)(nil), "CMsgClientCreateFriendsGroupResponse") + proto.RegisterType((*CMsgClientDeleteFriendsGroup)(nil), "CMsgClientDeleteFriendsGroup") + proto.RegisterType((*CMsgClientDeleteFriendsGroupResponse)(nil), "CMsgClientDeleteFriendsGroupResponse") + proto.RegisterType((*CMsgClientRenameFriendsGroup)(nil), "CMsgClientRenameFriendsGroup") + proto.RegisterType((*CMsgClientRenameFriendsGroupResponse)(nil), "CMsgClientRenameFriendsGroupResponse") + proto.RegisterType((*CMsgClientAddFriendToGroup)(nil), "CMsgClientAddFriendToGroup") + proto.RegisterType((*CMsgClientAddFriendToGroupResponse)(nil), "CMsgClientAddFriendToGroupResponse") + proto.RegisterType((*CMsgClientRemoveFriendFromGroup)(nil), "CMsgClientRemoveFriendFromGroup") + proto.RegisterType((*CMsgClientRemoveFriendFromGroupResponse)(nil), "CMsgClientRemoveFriendFromGroupResponse") + proto.RegisterType((*CMsgClientRegisterKey)(nil), "CMsgClientRegisterKey") + proto.RegisterType((*CMsgClientPurchaseResponse)(nil), "CMsgClientPurchaseResponse") + proto.RegisterType((*CMsgClientActivateOEMLicense)(nil), "CMsgClientActivateOEMLicense") + proto.RegisterType((*CMsgClientRegisterOEMMachine)(nil), "CMsgClientRegisterOEMMachine") + proto.RegisterType((*CMsgClientRegisterOEMMachineResponse)(nil), "CMsgClientRegisterOEMMachineResponse") + proto.RegisterType((*CMsgClientPurchaseWithMachineID)(nil), "CMsgClientPurchaseWithMachineID") + proto.RegisterType((*CMsgTrading_InitiateTradeRequest)(nil), "CMsgTrading_InitiateTradeRequest") + proto.RegisterType((*CMsgTrading_InitiateTradeResponse)(nil), "CMsgTrading_InitiateTradeResponse") + proto.RegisterType((*CMsgTrading_CancelTradeRequest)(nil), "CMsgTrading_CancelTradeRequest") + proto.RegisterType((*CMsgTrading_StartSession)(nil), "CMsgTrading_StartSession") + proto.RegisterType((*CMsgClientEmailChange)(nil), "CMsgClientEmailChange") + proto.RegisterType((*CMsgClientEmailChangeResponse)(nil), "CMsgClientEmailChangeResponse") + proto.RegisterType((*CMsgClientGetCDNAuthToken)(nil), "CMsgClientGetCDNAuthToken") + proto.RegisterType((*CMsgClientGetDepotDecryptionKey)(nil), "CMsgClientGetDepotDecryptionKey") + proto.RegisterType((*CMsgClientGetDepotDecryptionKeyResponse)(nil), "CMsgClientGetDepotDecryptionKeyResponse") + proto.RegisterType((*CMsgClientGetAppBetaPasswords)(nil), "CMsgClientGetAppBetaPasswords") + proto.RegisterType((*CMsgClientGetAppBetaPasswordsResponse)(nil), "CMsgClientGetAppBetaPasswordsResponse") + proto.RegisterType((*CMsgClientGetAppBetaPasswordsResponse_BetaPassword)(nil), "CMsgClientGetAppBetaPasswordsResponse.BetaPassword") + proto.RegisterType((*CMsgClientCheckAppBetaPassword)(nil), "CMsgClientCheckAppBetaPassword") + proto.RegisterType((*CMsgClientCheckAppBetaPasswordResponse)(nil), "CMsgClientCheckAppBetaPasswordResponse") + proto.RegisterType((*CMsgClientCheckAppBetaPasswordResponse_BetaPassword)(nil), "CMsgClientCheckAppBetaPasswordResponse.BetaPassword") + proto.RegisterType((*CMsgClientUpdateAppJobReport)(nil), "CMsgClientUpdateAppJobReport") + proto.RegisterType((*CMsgClientDPContentStatsReport)(nil), "CMsgClientDPContentStatsReport") + proto.RegisterType((*CMsgClientGetCDNAuthTokenResponse)(nil), "CMsgClientGetCDNAuthTokenResponse") + proto.RegisterType((*CMsgDownloadRateStatistics)(nil), "CMsgDownloadRateStatistics") + proto.RegisterType((*CMsgDownloadRateStatistics_StatsInfo)(nil), "CMsgDownloadRateStatistics.StatsInfo") + proto.RegisterType((*CMsgClientRequestAccountData)(nil), "CMsgClientRequestAccountData") + proto.RegisterType((*CMsgClientRequestAccountDataResponse)(nil), "CMsgClientRequestAccountDataResponse") + proto.RegisterType((*CMsgClientUGSGetGlobalStats)(nil), "CMsgClientUGSGetGlobalStats") + proto.RegisterType((*CMsgClientUGSGetGlobalStatsResponse)(nil), "CMsgClientUGSGetGlobalStatsResponse") + proto.RegisterType((*CMsgClientUGSGetGlobalStatsResponse_Day)(nil), "CMsgClientUGSGetGlobalStatsResponse.Day") + proto.RegisterType((*CMsgClientUGSGetGlobalStatsResponse_Day_Stat)(nil), "CMsgClientUGSGetGlobalStatsResponse.Day.Stat") + proto.RegisterType((*CMsgGameServerData)(nil), "CMsgGameServerData") + proto.RegisterType((*CMsgGameServerData_Player)(nil), "CMsgGameServerData.Player") + proto.RegisterType((*CMsgGameServerRemove)(nil), "CMsgGameServerRemove") + proto.RegisterType((*CMsgClientGMSServerQuery)(nil), "CMsgClientGMSServerQuery") + proto.RegisterType((*CMsgGMSClientServerQueryResponse)(nil), "CMsgGMSClientServerQueryResponse") + proto.RegisterType((*CMsgGMSClientServerQueryResponse_Server)(nil), "CMsgGMSClientServerQueryResponse.Server") + proto.RegisterType((*CMsgGameServerOutOfDate)(nil), "CMsgGameServerOutOfDate") + proto.RegisterType((*CMsgClientRedeemGuestPass)(nil), "CMsgClientRedeemGuestPass") + proto.RegisterType((*CMsgClientRedeemGuestPassResponse)(nil), "CMsgClientRedeemGuestPassResponse") + proto.RegisterType((*CMsgClientGetClanActivityCounts)(nil), "CMsgClientGetClanActivityCounts") + proto.RegisterType((*CMsgClientGetClanActivityCountsResponse)(nil), "CMsgClientGetClanActivityCountsResponse") + proto.RegisterType((*CMsgClientOGSReportString)(nil), "CMsgClientOGSReportString") + proto.RegisterType((*CMsgClientOGSReportBug)(nil), "CMsgClientOGSReportBug") + proto.RegisterType((*CMsgGSAssociateWithClan)(nil), "CMsgGSAssociateWithClan") + proto.RegisterType((*CMsgGSAssociateWithClanResponse)(nil), "CMsgGSAssociateWithClanResponse") + proto.RegisterType((*CMsgGSComputeNewPlayerCompatibility)(nil), "CMsgGSComputeNewPlayerCompatibility") + proto.RegisterType((*CMsgGSComputeNewPlayerCompatibilityResponse)(nil), "CMsgGSComputeNewPlayerCompatibilityResponse") + proto.RegisterType((*CMsgClientSentLogs)(nil), "CMsgClientSentLogs") + proto.RegisterType((*CMsgGCClient)(nil), "CMsgGCClient") + proto.RegisterType((*CMsgClientRequestFreeLicense)(nil), "CMsgClientRequestFreeLicense") + proto.RegisterType((*CMsgClientRequestFreeLicenseResponse)(nil), "CMsgClientRequestFreeLicenseResponse") + proto.RegisterType((*CMsgDRMDownloadRequestWithCrashData)(nil), "CMsgDRMDownloadRequestWithCrashData") + proto.RegisterType((*CMsgDRMDownloadResponse)(nil), "CMsgDRMDownloadResponse") + proto.RegisterType((*CMsgDRMFinalResult)(nil), "CMsgDRMFinalResult") + proto.RegisterType((*CMsgClientDPCheckSpecialSurvey)(nil), "CMsgClientDPCheckSpecialSurvey") + proto.RegisterType((*CMsgClientDPCheckSpecialSurveyResponse)(nil), "CMsgClientDPCheckSpecialSurveyResponse") + proto.RegisterType((*CMsgClientDPSendSpecialSurveyResponse)(nil), "CMsgClientDPSendSpecialSurveyResponse") + proto.RegisterType((*CMsgClientDPSendSpecialSurveyResponseReply)(nil), "CMsgClientDPSendSpecialSurveyResponseReply") + proto.RegisterType((*CMsgClientRequestForgottenPasswordEmail)(nil), "CMsgClientRequestForgottenPasswordEmail") + proto.RegisterType((*CMsgClientRequestForgottenPasswordEmailResponse)(nil), "CMsgClientRequestForgottenPasswordEmailResponse") + proto.RegisterType((*CMsgClientItemAnnouncements)(nil), "CMsgClientItemAnnouncements") + proto.RegisterType((*CMsgClientRequestItemAnnouncements)(nil), "CMsgClientRequestItemAnnouncements") + proto.RegisterType((*CMsgClientUserNotifications)(nil), "CMsgClientUserNotifications") + proto.RegisterType((*CMsgClientUserNotifications_Notification)(nil), "CMsgClientUserNotifications.Notification") + proto.RegisterType((*CMsgClientCommentNotifications)(nil), "CMsgClientCommentNotifications") + proto.RegisterType((*CMsgClientRequestCommentNotifications)(nil), "CMsgClientRequestCommentNotifications") + proto.RegisterType((*CMsgClientOfflineMessageNotification)(nil), "CMsgClientOfflineMessageNotification") + proto.RegisterType((*CMsgClientRequestOfflineMessageCount)(nil), "CMsgClientRequestOfflineMessageCount") + proto.RegisterType((*CMsgClientFSGetFriendMessageHistory)(nil), "CMsgClientFSGetFriendMessageHistory") + proto.RegisterType((*CMsgClientFSGetFriendMessageHistoryResponse)(nil), "CMsgClientFSGetFriendMessageHistoryResponse") + proto.RegisterType((*CMsgClientFSGetFriendMessageHistoryResponse_FriendMessage)(nil), "CMsgClientFSGetFriendMessageHistoryResponse.FriendMessage") + proto.RegisterType((*CMsgClientFSGetFriendMessageHistoryForOfflineMessages)(nil), "CMsgClientFSGetFriendMessageHistoryForOfflineMessages") + proto.RegisterType((*CMsgClientFSGetFriendsSteamLevels)(nil), "CMsgClientFSGetFriendsSteamLevels") + proto.RegisterType((*CMsgClientFSGetFriendsSteamLevelsResponse)(nil), "CMsgClientFSGetFriendsSteamLevelsResponse") + proto.RegisterType((*CMsgClientFSGetFriendsSteamLevelsResponse_Friend)(nil), "CMsgClientFSGetFriendsSteamLevelsResponse.Friend") + proto.RegisterType((*CMsgClientEmailAddrInfo)(nil), "CMsgClientEmailAddrInfo") + proto.RegisterType((*CMsgCREEnumeratePublishedFiles)(nil), "CMsgCREEnumeratePublishedFiles") + proto.RegisterType((*CMsgCREEnumeratePublishedFilesResponse)(nil), "CMsgCREEnumeratePublishedFilesResponse") + proto.RegisterType((*CMsgCREEnumeratePublishedFilesResponse_PublishedFileId)(nil), "CMsgCREEnumeratePublishedFilesResponse.PublishedFileId") + proto.RegisterType((*CMsgCREItemVoteSummary)(nil), "CMsgCREItemVoteSummary") + proto.RegisterType((*CMsgCREItemVoteSummary_PublishedFileId)(nil), "CMsgCREItemVoteSummary.PublishedFileId") + proto.RegisterType((*CMsgCREItemVoteSummaryResponse)(nil), "CMsgCREItemVoteSummaryResponse") + proto.RegisterType((*CMsgCREItemVoteSummaryResponse_ItemVoteSummary)(nil), "CMsgCREItemVoteSummaryResponse.ItemVoteSummary") + proto.RegisterType((*CMsgCREUpdateUserPublishedItemVote)(nil), "CMsgCREUpdateUserPublishedItemVote") + proto.RegisterType((*CMsgCREUpdateUserPublishedItemVoteResponse)(nil), "CMsgCREUpdateUserPublishedItemVoteResponse") + proto.RegisterType((*CMsgCREGetUserPublishedItemVoteDetails)(nil), "CMsgCREGetUserPublishedItemVoteDetails") + proto.RegisterType((*CMsgCREGetUserPublishedItemVoteDetails_PublishedFileId)(nil), "CMsgCREGetUserPublishedItemVoteDetails.PublishedFileId") + proto.RegisterType((*CMsgCREGetUserPublishedItemVoteDetailsResponse)(nil), "CMsgCREGetUserPublishedItemVoteDetailsResponse") + proto.RegisterType((*CMsgCREGetUserPublishedItemVoteDetailsResponse_UserItemVoteDetail)(nil), "CMsgCREGetUserPublishedItemVoteDetailsResponse.UserItemVoteDetail") + proto.RegisterType((*CMsgGameServerPingSample)(nil), "CMsgGameServerPingSample") + proto.RegisterType((*CMsgGameServerPingSample_Sample)(nil), "CMsgGameServerPingSample.Sample") + proto.RegisterType((*CMsgFSGetFollowerCount)(nil), "CMsgFSGetFollowerCount") + proto.RegisterType((*CMsgFSGetFollowerCountResponse)(nil), "CMsgFSGetFollowerCountResponse") + proto.RegisterType((*CMsgFSGetIsFollowing)(nil), "CMsgFSGetIsFollowing") + proto.RegisterType((*CMsgFSGetIsFollowingResponse)(nil), "CMsgFSGetIsFollowingResponse") + proto.RegisterType((*CMsgFSEnumerateFollowingList)(nil), "CMsgFSEnumerateFollowingList") + proto.RegisterType((*CMsgFSEnumerateFollowingListResponse)(nil), "CMsgFSEnumerateFollowingListResponse") + proto.RegisterType((*CMsgDPGetNumberOfCurrentPlayers)(nil), "CMsgDPGetNumberOfCurrentPlayers") + proto.RegisterType((*CMsgDPGetNumberOfCurrentPlayersResponse)(nil), "CMsgDPGetNumberOfCurrentPlayersResponse") + proto.RegisterType((*CMsgClientFriendUserStatusPublished)(nil), "CMsgClientFriendUserStatusPublished") + proto.RegisterType((*CMsgClientServiceMethod)(nil), "CMsgClientServiceMethod") + proto.RegisterType((*CMsgClientServiceMethodResponse)(nil), "CMsgClientServiceMethodResponse") + proto.RegisterType((*CMsgClientUIMode)(nil), "CMsgClientUIMode") + proto.RegisterType((*CMsgClientVanityURLChangedNotification)(nil), "CMsgClientVanityURLChangedNotification") + proto.RegisterType((*CMsgClientAuthorizeLocalDeviceRequest)(nil), "CMsgClientAuthorizeLocalDeviceRequest") + proto.RegisterType((*CMsgClientAuthorizeLocalDevice)(nil), "CMsgClientAuthorizeLocalDevice") + proto.RegisterType((*CMsgClientDeauthorizeDeviceRequest)(nil), "CMsgClientDeauthorizeDeviceRequest") + proto.RegisterType((*CMsgClientDeauthorizeDevice)(nil), "CMsgClientDeauthorizeDevice") + proto.RegisterType((*CMsgClientUseLocalDeviceAuthorizations)(nil), "CMsgClientUseLocalDeviceAuthorizations") + proto.RegisterType((*CMsgClientUseLocalDeviceAuthorizations_DeviceToken)(nil), "CMsgClientUseLocalDeviceAuthorizations.DeviceToken") + proto.RegisterType((*CMsgClientGetAuthorizedDevices)(nil), "CMsgClientGetAuthorizedDevices") + proto.RegisterType((*CMsgClientGetAuthorizedDevicesResponse)(nil), "CMsgClientGetAuthorizedDevicesResponse") + proto.RegisterType((*CMsgClientGetAuthorizedDevicesResponse_AuthorizedDevice)(nil), "CMsgClientGetAuthorizedDevicesResponse.AuthorizedDevice") + proto.RegisterType((*CMsgClientGetEmoticonList)(nil), "CMsgClientGetEmoticonList") + proto.RegisterType((*CMsgClientEmoticonList)(nil), "CMsgClientEmoticonList") + proto.RegisterType((*CMsgClientEmoticonList_Emoticon)(nil), "CMsgClientEmoticonList.Emoticon") + proto.RegisterType((*CMsgClientSharedLibraryLockStatus)(nil), "CMsgClientSharedLibraryLockStatus") + proto.RegisterType((*CMsgClientSharedLibraryLockStatus_LockedLibrary)(nil), "CMsgClientSharedLibraryLockStatus.LockedLibrary") + proto.RegisterType((*CMsgClientSharedLibraryStopPlaying)(nil), "CMsgClientSharedLibraryStopPlaying") + proto.RegisterType((*CMsgClientSharedLibraryStopPlaying_StopApp)(nil), "CMsgClientSharedLibraryStopPlaying.StopApp") + proto.RegisterType((*CMsgClientServiceCall)(nil), "CMsgClientServiceCall") + proto.RegisterType((*CMsgClientServiceModule)(nil), "CMsgClientServiceModule") + proto.RegisterType((*CMsgClientServiceCallResponse)(nil), "CMsgClientServiceCallResponse") + proto.RegisterType((*CMsgAMUnlockStreaming)(nil), "CMsgAMUnlockStreaming") + proto.RegisterType((*CMsgAMUnlockStreamingResponse)(nil), "CMsgAMUnlockStreamingResponse") + proto.RegisterType((*CMsgClientPlayingSessionState)(nil), "CMsgClientPlayingSessionState") + proto.RegisterType((*CMsgClientKickPlayingSession)(nil), "CMsgClientKickPlayingSession") + proto.RegisterType((*CMsgClientCreateAccount)(nil), "CMsgClientCreateAccount") + proto.RegisterType((*CMsgClientCreateAccountResponse)(nil), "CMsgClientCreateAccountResponse") + proto.RegisterType((*CMsgClientVoiceCallPreAuthorize)(nil), "CMsgClientVoiceCallPreAuthorize") + proto.RegisterType((*CMsgClientVoiceCallPreAuthorizeResponse)(nil), "CMsgClientVoiceCallPreAuthorizeResponse") +} + +var client_server_2_fileDescriptor0 = []byte{ + // 6736 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x3c, 0x4b, 0x8c, 0x24, 0xc9, + 0x55, 0xd4, 0xa7, 0x7f, 0xd1, 0xdd, 0x33, 0xb3, 0x35, 0xb3, 0x3b, 0xed, 0x9a, 0xfd, 0x8c, 0xd3, + 0x3b, 0xde, 0x9f, 0xb7, 0x76, 0x7e, 0xfb, 0x1b, 0xbc, 0xeb, 0xed, 0xe9, 0x9e, 0xe9, 0x1d, 0xcf, + 0xcc, 0x4e, 0xd3, 0xbd, 0xb3, 0x8b, 0x2c, 0x50, 0x92, 0x95, 0x19, 0x5d, 0x9d, 0xee, 0xac, 0xca, + 0x74, 0x66, 0x56, 0xf7, 0x94, 0x4f, 0xc8, 0x27, 0x10, 0x07, 0x84, 0x64, 0x10, 0x16, 0x32, 0xc8, + 0xe2, 0xc0, 0x01, 0x21, 0x2e, 0x96, 0x30, 0x12, 0x1c, 0x40, 0x82, 0x0b, 0x12, 0xc8, 0x80, 0x04, + 0x12, 0x27, 0x4e, 0x48, 0xc0, 0x85, 0x03, 0x42, 0x82, 0x0b, 0xef, 0x13, 0x91, 0x19, 0x99, 0x59, + 0x95, 0xdd, 0xbd, 0xb6, 0xe1, 0xb2, 0x3b, 0x15, 0x19, 0xf1, 0xde, 0x8b, 0x17, 0x2f, 0xde, 0x3f, + 0x5a, 0x58, 0x49, 0x2a, 0x9d, 0xe1, 0x50, 0x26, 0x89, 0x33, 0x90, 0x89, 0xed, 0x06, 0xbe, 0x1c, + 0xa5, 0x89, 0x8c, 0x0f, 0x65, 0x6c, 0x5f, 0xef, 0x45, 0x71, 0x98, 0x86, 0xdd, 0xb5, 0xe2, 0x9c, + 0xbe, 0x93, 0x48, 0xf5, 0xa5, 0x2b, 0x47, 0x6e, 0x3c, 0x89, 0x52, 0xe9, 0xd9, 0x4e, 0x14, 0xd9, + 0xa9, 0xef, 0x1e, 0xc8, 0x94, 0xbf, 0x59, 0xff, 0xde, 0x14, 0xdd, 0x8d, 0x87, 0xc9, 0x60, 0x83, + 0x40, 0x3e, 0xde, 0x78, 0xb8, 0xee, 0x79, 0xbb, 0x6e, 0x2c, 0xe5, 0x28, 0xd9, 0x0f, 0xd3, 0xce, + 0xaa, 0x98, 0x83, 0x25, 0xbe, 0xb7, 0xd6, 0xb8, 0xdc, 0x78, 0x79, 0xb5, 0x73, 0x4e, 0x2c, 0xee, + 0xf9, 0x81, 0x1c, 0x39, 0x43, 0xb9, 0xd6, 0x84, 0x91, 0xa5, 0xce, 0x53, 0x62, 0x29, 0xdd, 0x1f, + 0x0f, 0xfb, 0x34, 0xd4, 0xa2, 0xa1, 0x8b, 0xe2, 0x6c, 0x9c, 0xfa, 0x43, 0x79, 0xe3, 0xba, 0x0d, + 0x80, 0x1c, 0x40, 0xbb, 0xd6, 0x86, 0x0f, 0x0b, 0x08, 0xec, 0xc8, 0xf7, 0xd2, 0xfd, 0xb5, 0x39, + 0x02, 0x76, 0x46, 0xcc, 0xef, 0x4b, 0x7f, 0xb0, 0x9f, 0xae, 0xcd, 0xd3, 0xef, 0xf3, 0x62, 0x39, + 0x92, 0xf1, 0xd0, 0x4f, 0x12, 0x3f, 0x1c, 0x25, 0x6b, 0x0b, 0x34, 0x78, 0x56, 0x2c, 0xb8, 0x4e, + 0x94, 0xc2, 0xc8, 0xda, 0x22, 0x41, 0x7f, 0x5a, 0xac, 0x02, 0x65, 0x71, 0xea, 0x8e, 0x53, 0x9b, + 0x90, 0x2e, 0xd1, 0xf0, 0x97, 0x44, 0x2b, 0x75, 0x06, 0x6b, 0xe2, 0x72, 0xeb, 0xe5, 0xe5, 0xeb, + 0x2f, 0xf4, 0x66, 0x6f, 0xa9, 0xf7, 0xb1, 0x33, 0xe8, 0x3c, 0x23, 0xce, 0xc0, 0xec, 0x01, 0x30, + 0x84, 0x98, 0x06, 0xfb, 0x5b, 0x86, 0x85, 0xf3, 0x48, 0x42, 0x12, 0x85, 0xb0, 0xc3, 0xd8, 0x46, + 0x68, 0x2b, 0x00, 0x7a, 0xb1, 0xf3, 0xbc, 0x78, 0x46, 0x4d, 0x8e, 0xc6, 0xfd, 0xc0, 0x4f, 0xf6, + 0xa5, 0x87, 0x4c, 0x80, 0x45, 0xab, 0xb0, 0xa8, 0xdd, 0x7d, 0x55, 0xb4, 0x10, 0x26, 0xf0, 0x06, + 0xa6, 0x31, 0x4d, 0x8d, 0x8c, 0x37, 0x30, 0x72, 0xe8, 0x04, 0x63, 0xc5, 0x2e, 0xcb, 0x13, 0xd6, + 0x6c, 0xd2, 0x76, 0x24, 0x20, 0x1f, 0x25, 0xb2, 0xd3, 0x11, 0x0b, 0x32, 0x96, 0xc9, 0x38, 0x48, + 0x09, 0xd2, 0xdc, 0xad, 0xc6, 0xf5, 0xce, 0xab, 0x62, 0x25, 0xc9, 0x66, 0x02, 0x6e, 0x84, 0x37, + 0x7f, 0xeb, 0xc2, 0xb5, 0x77, 0x6e, 0xde, 0x7c, 0xeb, 0xed, 0x9b, 0x37, 0xaf, 0xbe, 0x7d, 0xe3, + 0xed, 0xab, 0xef, 0xbe, 0xf9, 0xe6, 0xb5, 0xb7, 0xae, 0xbd, 0x69, 0xdd, 0x17, 0xcf, 0x15, 0xb0, + 0x6c, 0xca, 0x40, 0xa6, 0xd2, 0x38, 0xd6, 0x32, 0xb0, 0x46, 0x0d, 0xb0, 0x9f, 0x16, 0x57, 0x6a, + 0x81, 0xd5, 0x51, 0x6d, 0xfd, 0xb0, 0x29, 0xd6, 0x0a, 0xab, 0xb7, 0x99, 0x85, 0x77, 0x81, 0x81, + 0x28, 0x00, 0x28, 0x8f, 0x99, 0x74, 0x01, 0xbf, 0x90, 0xb1, 0xb6, 0x21, 0x5e, 0x9f, 0x13, 0x4f, + 0x45, 0xb1, 0x3c, 0xf4, 0xe5, 0x91, 0x9d, 0x7f, 0xca, 0xc4, 0xcc, 0x05, 0xbc, 0xe3, 0x21, 0x1c, + 0x96, 0x02, 0xd3, 0x26, 0x30, 0x20, 0x66, 0xa9, 0x9f, 0x06, 0x92, 0xc4, 0x6c, 0x09, 0xcf, 0xd4, + 0x93, 0xb0, 0x5b, 0x9f, 0xa5, 0x68, 0x9e, 0x06, 0x57, 0x44, 0x1b, 0x8e, 0x26, 0x01, 0x99, 0x6a, + 0xb1, 0x4c, 0x1d, 0x85, 0xf1, 0x01, 0xec, 0x26, 0x22, 0x34, 0x24, 0x53, 0x8b, 0xb0, 0x21, 0x71, + 0xe8, 0x27, 0x7e, 0xdf, 0x0f, 0xfc, 0x74, 0x02, 0xa2, 0x05, 0x7b, 0xca, 0x68, 0x4c, 0x27, 0x91, + 0x04, 0xa1, 0x41, 0x7c, 0xcb, 0xa2, 0x35, 0x8e, 0x03, 0x12, 0x96, 0x25, 0x94, 0xac, 0x43, 0xdf, + 0x93, 0xa1, 0x0d, 0xd7, 0x0b, 0xff, 0x11, 0x83, 0x90, 0xe0, 0xa4, 0xae, 0xe8, 0xf0, 0xb8, 0xe3, + 0xba, 0xe1, 0x78, 0xa4, 0x64, 0xf7, 0x0c, 0xad, 0x59, 0x13, 0xe7, 0xf8, 0x1b, 0xfc, 0x67, 0x94, + 0xfa, 0x7b, 0x3e, 0xac, 0x3a, 0xab, 0x69, 0xf7, 0x47, 0x08, 0x6a, 0x00, 0x8c, 0x4d, 0xd6, 0xce, + 0x21, 0x59, 0xd6, 0xf7, 0x1a, 0xe2, 0xf2, 0x2c, 0x9e, 0xd6, 0x8a, 0xd0, 0x1b, 0xc0, 0x4c, 0x2d, + 0xc1, 0xcc, 0xce, 0x7a, 0x39, 0xea, 0xbc, 0x23, 0x5e, 0x19, 0x49, 0xe9, 0x25, 0x76, 0xc6, 0x9d, + 0x40, 0x0e, 0x9c, 0xc0, 0x76, 0x80, 0x1c, 0x39, 0x04, 0xe4, 0xb8, 0x1b, 0x19, 0xa5, 0xce, 0xc8, + 0xe5, 0x53, 0x59, 0xbc, 0x35, 0xb7, 0xe7, 0x04, 0x89, 0xb4, 0x7e, 0x75, 0xae, 0x44, 0xe3, 0xe3, + 0xc8, 0x03, 0x4d, 0xb0, 0xad, 0xd1, 0x4f, 0x3d, 0xff, 0xcf, 0xcd, 0xa4, 0xaf, 0x28, 0x1a, 0xad, + 0xd9, 0xa2, 0xd1, 0xa6, 0x4f, 0xa7, 0x91, 0x80, 0x05, 0x92, 0x80, 0xe2, 0x51, 0x2f, 0xd2, 0x51, + 0xc3, 0xb2, 0x31, 0x51, 0x6d, 0xca, 0xc4, 0x25, 0x71, 0x5e, 0x0d, 0x9a, 0xc8, 0x49, 0x38, 0x16, + 0x3b, 0x17, 0xc4, 0x8a, 0xfa, 0xc8, 0xe8, 0x97, 0x69, 0x14, 0x8e, 0x5e, 0x8d, 0x9a, 0x54, 0xb0, + 0x6e, 0xc9, 0x71, 0x10, 0x31, 0xab, 0x34, 0x08, 0x3b, 0x53, 0x83, 0x06, 0x4d, 0x67, 0x34, 0x2c, + 0x77, 0xdf, 0x19, 0x0d, 0x8a, 0xb0, 0x58, 0x58, 0x60, 0x0f, 0x6a, 0x19, 0x8a, 0x23, 0xc9, 0x8a, + 0x96, 0xcd, 0xa7, 0x68, 0xc2, 0x0b, 0xe2, 0xa2, 0x9a, 0x00, 0x17, 0x27, 0xc5, 0xe3, 0x1b, 0x3a, + 0x23, 0x7f, 0x4f, 0x26, 0xe9, 0x5a, 0x87, 0x66, 0x83, 0x20, 0x56, 0xbe, 0x9c, 0x27, 0xfe, 0x83, + 0x72, 0x1b, 0xca, 0xd4, 0x81, 0xc5, 0xce, 0xda, 0x05, 0x7d, 0xfd, 0x14, 0xb0, 0xec, 0xc3, 0xd3, + 0x6a, 0x4b, 0x8b, 0x01, 0x50, 0x38, 0x06, 0x2b, 0xb4, 0xf6, 0x0c, 0x8b, 0xde, 0x55, 0xbc, 0x16, + 0xb1, 0x1c, 0x86, 0x87, 0x70, 0xb0, 0x07, 0x87, 0xb4, 0xd5, 0x8b, 0xc4, 0xf7, 0xf7, 0xc4, 0xbc, + 0xfa, 0xbd, 0x46, 0x9a, 0xfb, 0xf5, 0xde, 0x71, 0x52, 0xd3, 0xbb, 0x2f, 0x27, 0x9f, 0xa0, 0x46, + 0x05, 0x9d, 0xdb, 0x7d, 0x45, 0x2c, 0x1b, 0x3f, 0x71, 0xb7, 0x07, 0x72, 0xa2, 0xb4, 0x2f, 0x08, + 0x81, 0xa9, 0x79, 0x9f, 0x88, 0x97, 0x8f, 0x03, 0x5d, 0x7b, 0x79, 0x4e, 0x75, 0x17, 0x9a, 0xe6, + 0x5d, 0x78, 0xaf, 0x74, 0x15, 0x58, 0x81, 0x16, 0xaf, 0xc2, 0x54, 0xd1, 0x27, 0xad, 0x6c, 0xbd, + 0x5f, 0x22, 0x7c, 0xca, 0xf2, 0x5a, 0x15, 0xec, 0x96, 0xd6, 0xdf, 0x19, 0xa1, 0xca, 0x84, 0xbd, + 0x3f, 0x06, 0x07, 0xa2, 0x00, 0x26, 0xa9, 0xdc, 0x48, 0xb4, 0x87, 0xa9, 0x13, 0xa7, 0xb6, 0x3f, + 0xf2, 0xe4, 0x13, 0xda, 0xd6, 0x2a, 0xca, 0x59, 0x02, 0x06, 0xd8, 0x0e, 0x63, 0x54, 0x6f, 0x78, + 0x19, 0x57, 0xad, 0x7f, 0x69, 0x88, 0xab, 0x27, 0xc5, 0x52, 0xcb, 0xe6, 0xaf, 0x89, 0xb3, 0x45, + 0x46, 0x24, 0x80, 0x15, 0x25, 0x63, 0xbd, 0x77, 0x5a, 0xf8, 0xbd, 0xc2, 0xf0, 0x3d, 0x0f, 0xd5, + 0x7c, 0x1a, 0xa6, 0x70, 0x66, 0x8c, 0x34, 0x61, 0xda, 0xbb, 0x5f, 0x12, 0x67, 0xcb, 0x33, 0x6b, + 0x8e, 0xe3, 0x37, 0x1b, 0xe2, 0x95, 0xd9, 0x94, 0xec, 0x8e, 0xfb, 0x78, 0x2d, 0xfb, 0xa7, 0x62, + 0xe8, 0x05, 0xb1, 0x04, 0xa8, 0x52, 0xb6, 0x29, 0x44, 0xd3, 0xad, 0xc6, 0xb5, 0xce, 0x73, 0xa2, + 0x33, 0x74, 0x52, 0x77, 0xdf, 0x1f, 0x0d, 0xec, 0xdc, 0xe4, 0xb4, 0xf9, 0xf3, 0x55, 0xd0, 0x88, + 0x73, 0x64, 0x48, 0xd8, 0x99, 0xba, 0xd5, 0x7c, 0xf3, 0xaa, 0xf5, 0xcb, 0x4d, 0x71, 0xed, 0xc4, + 0xa4, 0xd5, 0x9e, 0xc2, 0xcf, 0x89, 0x73, 0x49, 0x36, 0xbd, 0x70, 0x0c, 0xb7, 0x7b, 0xa7, 0xc6, + 0x70, 0xd2, 0x73, 0xb8, 0x7f, 0x9a, 0x73, 0x40, 0xf6, 0x68, 0x2f, 0x33, 0x27, 0x95, 0x18, 0xba, + 0x00, 0xec, 0xb1, 0x42, 0x71, 0xf3, 0xc4, 0x84, 0x7e, 0xea, 0xa7, 0xfb, 0xac, 0x0e, 0x4e, 0x71, + 0x03, 0x68, 0x10, 0x09, 0x20, 0xea, 0x17, 0xac, 0x5f, 0x6b, 0x89, 0x2f, 0x7f, 0x16, 0x8c, 0xb5, + 0xe7, 0x30, 0x98, 0x79, 0x0e, 0x0f, 0x7b, 0x3f, 0x0a, 0xb2, 0x93, 0x1e, 0xc9, 0x9f, 0x34, 0x7e, + 0x8c, 0x67, 0x92, 0x07, 0x13, 0x04, 0x1c, 0x71, 0xd2, 0xf2, 0x7d, 0x65, 0x73, 0x48, 0xb6, 0x73, + 0x53, 0x9f, 0xf8, 0xdf, 0x94, 0x2a, 0x52, 0x78, 0x56, 0x5c, 0xd0, 0x70, 0x03, 0x07, 0x2e, 0x0a, + 0x1b, 0x1e, 0x8f, 0x2c, 0xf9, 0x02, 0x5a, 0x2d, 0x3f, 0x01, 0x7b, 0x18, 0x85, 0xa9, 0x36, 0x6c, + 0x14, 0x3c, 0x2c, 0x5a, 0x7f, 0xd9, 0x10, 0x2f, 0x4e, 0xf3, 0x94, 0x78, 0x2f, 0x39, 0x9b, 0xea, + 0xf6, 0x94, 0x0b, 0x44, 0x73, 0x3a, 0xd5, 0xad, 0x2a, 0xd5, 0xec, 0x87, 0x02, 0x5d, 0x44, 0xb5, + 0xc9, 0x8b, 0x39, 0xfd, 0xa5, 0x42, 0xf1, 0x3c, 0x19, 0x4f, 0x80, 0xce, 0x6b, 0xf4, 0x16, 0x29, + 0x0a, 0xb2, 0x76, 0xc5, 0x17, 0x67, 0xef, 0xe3, 0xf1, 0x28, 0xf9, 0x2c, 0x3b, 0xb1, 0x3e, 0x12, + 0x9f, 0x9f, 0x0d, 0x94, 0xad, 0xcc, 0xa9, 0xe0, 0xfd, 0x6e, 0xa3, 0x0e, 0x20, 0x4b, 0xe0, 0xa9, + 0x58, 0x0d, 0xee, 0x54, 0x81, 0x17, 0x2d, 0x1d, 0x83, 0x1e, 0x27, 0x31, 0x0b, 0xb3, 0x39, 0x6c, + 0x1d, 0x98, 0x22, 0xf1, 0xa9, 0xb2, 0xe5, 0xf7, 0x52, 0x39, 0xdc, 0x20, 0xbf, 0x0a, 0xae, 0xc8, + 0x37, 0xc6, 0xe0, 0xf7, 0x4c, 0x73, 0x4e, 0x49, 0xf6, 0x0a, 0x14, 0x35, 0xf5, 0x71, 0xc2, 0xf5, + 0xb3, 0x7d, 0x00, 0x92, 0xd8, 0xe8, 0x24, 0x68, 0x5a, 0xad, 0xff, 0x69, 0x98, 0xc1, 0xd3, 0x54, + 0x6c, 0x35, 0xb7, 0xdf, 0x70, 0x0e, 0x7d, 0x15, 0x11, 0xad, 0x76, 0x1e, 0x89, 0x33, 0x99, 0x07, + 0x42, 0x18, 0x61, 0xc7, 0xa8, 0x10, 0xde, 0xee, 0x9d, 0x08, 0x51, 0xcf, 0xfc, 0x76, 0x6f, 0xb4, + 0x17, 0x76, 0x7f, 0x56, 0x9c, 0x2b, 0x8f, 0xd5, 0x1d, 0x52, 0xf9, 0x50, 0x9a, 0x5a, 0x4d, 0x6a, + 0x8f, 0xd1, 0x56, 0x17, 0x7c, 0xde, 0xfa, 0xc7, 0x82, 0x40, 0x94, 0x91, 0x7c, 0x06, 0x46, 0x6f, + 0x55, 0xf6, 0xde, 0xa2, 0xbd, 0xbf, 0xd1, 0x3b, 0x16, 0x4d, 0x61, 0xdf, 0xdd, 0xaf, 0x88, 0x15, + 0xf3, 0xf7, 0xa9, 0xf7, 0x6b, 0xfd, 0x4e, 0xd3, 0x0c, 0xe4, 0xab, 0x38, 0x4f, 0x7b, 0xaa, 0x0f, + 0x66, 0xec, 0xec, 0x66, 0xef, 0x78, 0x2c, 0x95, 0x23, 0x45, 0x2d, 0x12, 0xc5, 0xfe, 0x21, 0xe2, + 0x60, 0x60, 0x6d, 0xcc, 0x6e, 0x74, 0x0f, 0x7e, 0x52, 0x27, 0x8d, 0x37, 0x10, 0xae, 0x1b, 0x3a, + 0xc4, 0xee, 0x84, 0x2e, 0xe5, 0xa2, 0xf5, 0xed, 0x46, 0x29, 0x6f, 0xb0, 0x25, 0xd3, 0xa2, 0x9f, + 0x76, 0x37, 0x8c, 0xd1, 0x5a, 0x55, 0x04, 0x00, 0xa3, 0x10, 0xcc, 0x1b, 0x85, 0x31, 0x67, 0x67, + 0xf2, 0x28, 0x10, 0xb5, 0x23, 0x1c, 0xa7, 0x1f, 0x03, 0xad, 0x14, 0x34, 0xb4, 0x74, 0xf8, 0x2e, + 0x9f, 0xb8, 0xc1, 0xd8, 0xd3, 0xc3, 0x6d, 0x1a, 0x2e, 0x99, 0x6e, 0x52, 0xbd, 0xd6, 0x3f, 0x37, + 0xc4, 0xeb, 0x27, 0x22, 0xab, 0xf6, 0x0c, 0x3f, 0x9d, 0xe5, 0xa5, 0xbe, 0xdf, 0x3b, 0x15, 0xf0, + 0x9f, 0x8c, 0x8b, 0xea, 0x89, 0x97, 0x0a, 0x54, 0xec, 0xca, 0xb4, 0xe2, 0x25, 0xaf, 0xbb, 0x18, + 0x39, 0x9e, 0x46, 0x1b, 0xe3, 0x6f, 0x5a, 0x44, 0x34, 0xcd, 0x59, 0x77, 0xc4, 0x1b, 0x27, 0xc4, + 0x52, 0x1b, 0x9e, 0x0c, 0x66, 0x05, 0x0e, 0x45, 0xc6, 0xdd, 0x9e, 0x20, 0x70, 0x45, 0xf5, 0x89, + 0x9c, 0xb4, 0x32, 0xbd, 0xdf, 0x6e, 0x8a, 0x77, 0x4e, 0x8b, 0xa9, 0x56, 0x08, 0xfa, 0xb3, 0x84, + 0xe0, 0x5e, 0xef, 0xb3, 0xe2, 0x39, 0xa9, 0x3c, 0xdc, 0x3b, 0x95, 0x5b, 0x76, 0x49, 0x3b, 0x22, + 0xec, 0x8d, 0xa4, 0xce, 0x30, 0xca, 0x1d, 0xe5, 0xe7, 0xc5, 0xb3, 0x39, 0xb5, 0x79, 0x56, 0x2f, + 0x61, 0xbb, 0xe1, 0x59, 0x47, 0xe6, 0x77, 0x36, 0xe2, 0x48, 0xf7, 0x96, 0x33, 0x94, 0xa4, 0x40, + 0x40, 0x4b, 0xa8, 0x1c, 0x2a, 0x20, 0x84, 0xbb, 0x97, 0x09, 0xcf, 0x00, 0x66, 0x64, 0x37, 0xf7, + 0xac, 0x58, 0xc0, 0xdf, 0xb6, 0x1f, 0x29, 0x2b, 0x0e, 0x1a, 0x83, 0x06, 0x22, 0x88, 0x24, 0x8d, + 0xbc, 0x5d, 0x78, 0x20, 0x47, 0x74, 0x53, 0x57, 0xc0, 0xe7, 0x31, 0x10, 0xef, 0xf8, 0xee, 0xfe, + 0x36, 0xf0, 0x40, 0x42, 0x74, 0xfd, 0x38, 0x0a, 0x42, 0xc7, 0x23, 0xf7, 0x0a, 0x46, 0x31, 0x0f, + 0x43, 0xc3, 0xf6, 0xc1, 0x21, 0x21, 0x5f, 0x41, 0x56, 0x68, 0x92, 0xfa, 0x31, 0x4c, 0x75, 0xc1, + 0x9c, 0xd0, 0xd1, 0xcc, 0x5b, 0xef, 0x98, 0x99, 0x51, 0x13, 0xa8, 0xb6, 0x46, 0x17, 0xc5, 0x59, + 0xbd, 0x36, 0xe6, 0x21, 0x00, 0x8a, 0x2b, 0xbf, 0xdb, 0x30, 0x13, 0xe5, 0xe6, 0x52, 0x62, 0xc3, + 0x57, 0x40, 0x35, 0x99, 0xd4, 0xd0, 0xaa, 0xe5, 0xeb, 0x2f, 0xf7, 0x66, 0xaf, 0xe9, 0x99, 0x03, + 0xdd, 0xf7, 0xc5, 0x8a, 0xf9, 0xdb, 0xe4, 0xeb, 0x18, 0xf8, 0xad, 0xf8, 0x3a, 0x6d, 0xd3, 0x4d, + 0x62, 0x57, 0xcf, 0x64, 0xd7, 0xc6, 0xbe, 0x74, 0x0f, 0xc8, 0xc7, 0xf5, 0x07, 0x23, 0x27, 0x1d, + 0xc7, 0x95, 0x64, 0x9b, 0xf5, 0x5f, 0x05, 0xdf, 0xb8, 0xba, 0x20, 0x13, 0xfd, 0xf2, 0x65, 0x5b, + 0x16, 0xad, 0x28, 0x53, 0x0a, 0x67, 0xf3, 0x7b, 0xd1, 0xaa, 0x54, 0x08, 0xda, 0x3a, 0xbb, 0x29, + 0x13, 0x0d, 0x55, 0xcd, 0x9d, 0xd3, 0x73, 0x93, 0x7d, 0x87, 0x13, 0x68, 0xf3, 0x74, 0x72, 0xc8, + 0x7d, 0x3d, 0x75, 0x5f, 0x3a, 0x98, 0x5f, 0x58, 0xa0, 0x0f, 0x0a, 0x2c, 0x79, 0x78, 0x8b, 0xda, + 0x39, 0x1c, 0xc8, 0x14, 0x3d, 0x05, 0x19, 0xc7, 0x61, 0x4c, 0xe9, 0xb9, 0xd5, 0x8e, 0x25, 0xba, + 0xf2, 0xd0, 0x09, 0x0e, 0x73, 0x8c, 0x2e, 0xee, 0xcc, 0x93, 0xa9, 0xe3, 0x07, 0x94, 0xa5, 0x5b, + 0xb5, 0xb6, 0xc5, 0xe7, 0x8c, 0x43, 0x01, 0x2c, 0x0f, 0x1d, 0x8c, 0xb2, 0xe5, 0xfa, 0x38, 0xdd, + 0x2f, 0xd0, 0xcf, 0x79, 0x24, 0xd8, 0x7f, 0xb8, 0xb7, 0x97, 0xc8, 0x54, 0x6d, 0x19, 0x24, 0xd7, + 0x1d, 0xf7, 0xc1, 0x3a, 0xc1, 0x4a, 0xe5, 0xe6, 0xfd, 0x75, 0xc1, 0xd1, 0x29, 0x81, 0xcc, 0x18, + 0x59, 0x05, 0x6d, 0x70, 0xaf, 0x69, 0x72, 0x8f, 0xb6, 0xd9, 0xaa, 0xf0, 0xa8, 0x4d, 0xac, 0x28, + 0x6f, 0x3c, 0x2b, 0xa6, 0x28, 0x2a, 0xe7, 0xb3, 0xba, 0xc9, 0xb8, 0x4f, 0x34, 0x2e, 0xe8, 0x98, + 0xb5, 0x3f, 0x81, 0x10, 0xd0, 0xa6, 0xb1, 0x45, 0xcd, 0x6e, 0x4d, 0x91, 0x0d, 0xe2, 0x94, 0xc6, + 0x13, 0xae, 0xa6, 0x58, 0x7f, 0xda, 0x10, 0x97, 0xca, 0xb7, 0xfe, 0x74, 0x5c, 0x02, 0x74, 0xc4, + 0xa5, 0xa3, 0x18, 0x3c, 0x10, 0xb5, 0x17, 0xb8, 0xe0, 0x44, 0x82, 0xda, 0x08, 0x00, 0x09, 0xd3, + 0x88, 0xd3, 0x1a, 0xbc, 0x89, 0x67, 0xc4, 0x19, 0x1c, 0x31, 0xd2, 0xe0, 0xf3, 0x5a, 0x84, 0x70, + 0x1c, 0x18, 0x01, 0x96, 0x3f, 0x91, 0xa0, 0xa4, 0x52, 0x25, 0x17, 0xa0, 0x1f, 0x09, 0x06, 0x28, + 0x36, 0x2f, 0xf6, 0xf7, 0x52, 0x16, 0x0e, 0xb4, 0xf2, 0x5f, 0xa8, 0xa1, 0xff, 0xff, 0xe7, 0x48, + 0x60, 0x1d, 0xb0, 0xe4, 0x28, 0x0e, 0x81, 0x21, 0x0b, 0x7a, 0x24, 0xe3, 0xc0, 0xa2, 0x2e, 0x2f, + 0xe0, 0x08, 0x27, 0x2e, 0x97, 0x66, 0x30, 0x45, 0xd0, 0x19, 0x7d, 0xaf, 0x59, 0x50, 0x90, 0xac, + 0xac, 0xea, 0x0f, 0xa9, 0x2b, 0x3a, 0x6a, 0x73, 0xea, 0xb8, 0x69, 0x0f, 0xb3, 0xf6, 0x09, 0x88, + 0x71, 0x9f, 0xc6, 0x4c, 0xde, 0xed, 0x25, 0x71, 0x3e, 0x08, 0xdd, 0x83, 0xac, 0x92, 0xa1, 0xac, + 0xec, 0x3c, 0x6d, 0xc0, 0xdc, 0xd2, 0xc2, 0x0c, 0xfa, 0x17, 0x67, 0x1e, 0xea, 0x12, 0x21, 0x28, + 0x30, 0x41, 0xe8, 0xdb, 0x3e, 0xe4, 0xad, 0x71, 0x9e, 0x7f, 0x59, 0x27, 0xb4, 0xcd, 0x51, 0x52, + 0x94, 0xee, 0x7e, 0x08, 0x14, 0x73, 0x35, 0xc6, 0x7a, 0xdb, 0xd4, 0x71, 0x55, 0x16, 0x65, 0x72, + 0x70, 0xb6, 0x68, 0xde, 0x57, 0xad, 0xdb, 0x05, 0x6d, 0x4a, 0x55, 0xcc, 0xbb, 0x31, 0xfc, 0xdb, + 0x4b, 0xb6, 0xe2, 0x70, 0x1c, 0xe1, 0x02, 0x5d, 0x39, 0x6c, 0x68, 0x0f, 0x78, 0x80, 0x5f, 0xf2, + 0xda, 0x95, 0xf5, 0x61, 0x41, 0xc1, 0x56, 0x60, 0xcc, 0x44, 0x4e, 0xc6, 0x12, 0x67, 0x28, 0x2d, + 0x3b, 0x67, 0x7d, 0x60, 0x52, 0xc3, 0x91, 0x79, 0x3d, 0x35, 0x15, 0x08, 0x05, 0x46, 0x54, 0x21, + 0x9c, 0x90, 0x11, 0x3b, 0x24, 0x4c, 0x65, 0xd4, 0x1a, 0x53, 0x43, 0x4b, 0x70, 0x99, 0x11, 0xa5, + 0x53, 0x28, 0xc3, 0xa8, 0x43, 0x6e, 0x98, 0xdc, 0x75, 0xcf, 0xe3, 0x55, 0x1f, 0x87, 0x33, 0x50, + 0x93, 0x1b, 0x48, 0x6c, 0x20, 0x8b, 0x49, 0x9e, 0x87, 0xf5, 0xa6, 0x19, 0xa8, 0x95, 0x61, 0xcc, + 0x46, 0xbd, 0x25, 0x5e, 0x30, 0x69, 0xc6, 0xd2, 0x05, 0xaf, 0xbc, 0x1b, 0x87, 0xc3, 0xd3, 0xe0, + 0xbf, 0x65, 0x3a, 0xe3, 0x53, 0x01, 0xcd, 0x26, 0xe2, 0x45, 0xf1, 0xb4, 0xb9, 0x76, 0xe0, 0xa3, + 0x82, 0xb9, 0x2f, 0x27, 0x85, 0x42, 0x87, 0x15, 0x99, 0x5c, 0xda, 0x1e, 0xc3, 0x0d, 0x70, 0x92, + 0xfa, 0x5a, 0x06, 0xdc, 0x9b, 0x48, 0xcd, 0x53, 0x8e, 0xa5, 0xcd, 0x16, 0x32, 0x61, 0x71, 0xe9, + 0x3c, 0x27, 0x9e, 0x36, 0x26, 0xb8, 0xd2, 0x8f, 0xd0, 0xb7, 0xde, 0x0b, 0x49, 0x33, 0xac, 0x58, + 0x7f, 0xd1, 0x30, 0xa5, 0x02, 0x5d, 0x58, 0x8c, 0x35, 0x1f, 0xdd, 0x79, 0xf8, 0xc0, 0x77, 0x25, + 0x22, 0x05, 0x0f, 0xac, 0xef, 0x87, 0x09, 0x56, 0x91, 0xc6, 0x7b, 0xa0, 0x1f, 0xd0, 0xf2, 0x2b, + 0x1d, 0xa4, 0x3f, 0x01, 0x87, 0x7c, 0x27, 0x00, 0xd7, 0xb8, 0xaf, 0x58, 0xb5, 0x84, 0x97, 0x3c, + 0x60, 0x00, 0xac, 0x5c, 0x09, 0x19, 0x96, 0xdf, 0x87, 0x8e, 0x3f, 0xea, 0x87, 0x4e, 0xec, 0x15, + 0x01, 0xb6, 0x35, 0xc0, 0xfc, 0x7b, 0x14, 0x87, 0xde, 0xd8, 0x4d, 0x55, 0xe1, 0xaf, 0xb0, 0xb4, + 0x80, 0x90, 0xec, 0x8a, 0xf5, 0x6e, 0x51, 0xb8, 0x99, 0xbf, 0xb0, 0x0d, 0xa5, 0x22, 0x10, 0x74, + 0x28, 0x87, 0xc0, 0x01, 0xfe, 0xc2, 0x54, 0x91, 0x8f, 0x59, 0x96, 0xe9, 0xf2, 0xd2, 0xd9, 0x67, + 0x7a, 0xdf, 0x14, 0x2c, 0x7d, 0x5a, 0x98, 0xa2, 0x55, 0x2b, 0xef, 0x6d, 0xa2, 0xed, 0x8c, 0x1c, + 0xf7, 0xc0, 0x19, 0xc8, 0xdc, 0xeb, 0x32, 0x14, 0x20, 0x1d, 0x04, 0x3b, 0x7d, 0x03, 0x2e, 0x2d, + 0x7d, 0x1c, 0x3b, 0x1e, 0x96, 0x09, 0xee, 0x8d, 0xfc, 0xd4, 0x87, 0x93, 0xc0, 0xdf, 0x99, 0x47, + 0x0b, 0x7a, 0x36, 0xc5, 0xdf, 0xda, 0x9f, 0xcd, 0x61, 0x92, 0xf1, 0xdc, 0x97, 0x71, 0xd6, 0x04, + 0x81, 0x40, 0xdb, 0x88, 0x9e, 0x87, 0xf3, 0x62, 0xab, 0xf5, 0xb7, 0x4d, 0xf6, 0x70, 0x66, 0x60, + 0xca, 0xcd, 0x69, 0xac, 0xfe, 0x9d, 0xc7, 0xf2, 0x15, 0xe4, 0xcd, 0xe9, 0xc8, 0x5b, 0x84, 0xfc, + 0xb2, 0xe0, 0x3e, 0x96, 0xc1, 0x18, 0xcf, 0x2c, 0x8b, 0xf6, 0x3d, 0x67, 0x92, 0xa8, 0x30, 0x01, + 0x66, 0x8c, 0xe4, 0x11, 0x08, 0xec, 0x21, 0xc8, 0x8a, 0xed, 0x86, 0x61, 0xe0, 0x85, 0x47, 0x23, + 0x9e, 0xc1, 0x86, 0xf7, 0x75, 0x71, 0xc5, 0x93, 0x7b, 0x0e, 0x8a, 0x75, 0xe4, 0x24, 0xc9, 0x51, + 0x48, 0x90, 0xc0, 0x10, 0xa3, 0x78, 0xf4, 0x1d, 0xb4, 0x56, 0x3c, 0x9d, 0xed, 0xf2, 0x15, 0xf1, + 0x5c, 0xfd, 0x34, 0xb6, 0x63, 0xaf, 0x89, 0x2f, 0x68, 0xa8, 0x12, 0xa4, 0x2a, 0xb0, 0x55, 0x21, + 0xb6, 0x34, 0x99, 0xbd, 0xd3, 0x2f, 0x88, 0x4b, 0x75, 0x93, 0xc8, 0xb2, 0x83, 0x0c, 0x3d, 0x6f, + 0xf2, 0x74, 0x03, 0x4b, 0x87, 0x41, 0xe1, 0xec, 0x2a, 0x4c, 0x42, 0xae, 0xb6, 0xad, 0x6b, 0xdc, + 0x54, 0xa1, 0x17, 0xee, 0x62, 0xec, 0xbb, 0x2b, 0xa9, 0x6f, 0x66, 0xd6, 0x92, 0x3f, 0x6c, 0x98, + 0xba, 0xe4, 0x0e, 0xd2, 0xc6, 0x11, 0x1e, 0x1e, 0x9a, 0xde, 0x7e, 0x5e, 0x39, 0x25, 0xe2, 0xd5, + 0xb5, 0x5c, 0x11, 0x6d, 0x37, 0xf4, 0x74, 0xd9, 0x1d, 0x3e, 0xee, 0xf9, 0x23, 0x27, 0xe0, 0x34, + 0x0f, 0xaa, 0x7b, 0x38, 0x8d, 0xa1, 0x4c, 0xf7, 0x43, 0xce, 0x6e, 0x2f, 0x52, 0x73, 0xcd, 0x51, + 0x88, 0xb7, 0x34, 0x8c, 0x6d, 0x5a, 0xc9, 0x5e, 0x1c, 0xfa, 0x4d, 0xc3, 0x84, 0x47, 0x16, 0x68, + 0x04, 0x3c, 0x09, 0x6e, 0x65, 0xb2, 0x93, 0x71, 0x84, 0x91, 0x20, 0xa8, 0x85, 0x21, 0xb3, 0x70, + 0xd1, 0xfa, 0xc8, 0x0c, 0xd5, 0x0c, 0x82, 0x6b, 0x35, 0x1b, 0xdc, 0x58, 0x25, 0x33, 0x04, 0x8a, + 0x91, 0x51, 0x35, 0xd6, 0x7a, 0xdf, 0x74, 0xfb, 0xb7, 0x64, 0xba, 0xb1, 0xf9, 0x11, 0xfa, 0x00, + 0x1f, 0x63, 0xc8, 0x39, 0xad, 0x15, 0x05, 0xfc, 0x88, 0xd4, 0x68, 0x45, 0xb1, 0x36, 0xcc, 0x8b, + 0x0b, 0xeb, 0x37, 0x31, 0xb9, 0xbc, 0x29, 0xa9, 0xb3, 0x0a, 0x18, 0x8f, 0x6a, 0x19, 0x76, 0xc8, + 0x29, 0xe7, 0x0c, 0x4e, 0x39, 0x47, 0x3e, 0x34, 0xad, 0xc1, 0x54, 0x20, 0xb5, 0xdb, 0x33, 0x11, + 0x34, 0x75, 0x69, 0x84, 0x47, 0x54, 0x8f, 0x17, 0x8a, 0x18, 0x9a, 0x06, 0x56, 0xd4, 0x6f, 0x98, + 0x3c, 0x04, 0x74, 0xeb, 0x51, 0x74, 0x1b, 0x14, 0xfd, 0xb6, 0x3a, 0xef, 0x4a, 0xb9, 0xcb, 0xfa, + 0x9b, 0x42, 0xd6, 0x6e, 0xca, 0x8a, 0x5a, 0xf2, 0xca, 0x29, 0xa3, 0xaf, 0x8a, 0xd5, 0x3e, 0x2c, + 0xd6, 0xe2, 0xa5, 0x93, 0x9a, 0x37, 0x7a, 0x27, 0x42, 0xd1, 0x33, 0x47, 0xbb, 0x6f, 0x89, 0x15, + 0xf3, 0x37, 0xb2, 0x02, 0x61, 0x1b, 0xde, 0x2d, 0xa8, 0x48, 0x13, 0x9b, 0x3a, 0xb6, 0xbb, 0x7c, + 0xc9, 0x8c, 0x30, 0xb7, 0x84, 0xaf, 0x72, 0xf6, 0xd3, 0xe1, 0xfc, 0x59, 0xc3, 0xac, 0xc1, 0x4c, + 0x03, 0x54, 0xcb, 0x9a, 0xfb, 0x65, 0x56, 0xb4, 0x2b, 0xf9, 0xdd, 0x3a, 0x98, 0x3f, 0x1e, 0x5e, + 0x7c, 0xbf, 0x59, 0x4d, 0xe6, 0x00, 0xc2, 0xaf, 0x86, 0xfd, 0x1d, 0x89, 0xd7, 0x6f, 0xda, 0x35, + 0xd0, 0xf2, 0xc6, 0xc9, 0x2d, 0x1a, 0xc2, 0x29, 0x49, 0xea, 0x64, 0x71, 0x1d, 0xa8, 0x9c, 0xaf, + 0x87, 0x7d, 0x6a, 0xc2, 0xe2, 0xf8, 0xa7, 0xad, 0x87, 0xe9, 0x67, 0xe6, 0x5b, 0xcc, 0x69, 0xd2, + 0x70, 0xb6, 0x37, 0x8e, 0x9d, 0x2c, 0x6e, 0x58, 0x45, 0x97, 0x84, 0xc2, 0x0f, 0xf4, 0xfa, 0x7d, + 0x8f, 0x55, 0xe5, 0x1e, 0xac, 0xd2, 0x25, 0x30, 0xb4, 0x24, 0x1c, 0xbf, 0xa2, 0xb6, 0xc7, 0x04, + 0x90, 0xe4, 0x28, 0xb6, 0x4d, 0x7b, 0xa5, 0x2f, 0x40, 0xd3, 0x00, 0x46, 0x97, 0x68, 0x14, 0xb4, + 0x10, 0x8f, 0xba, 0xe1, 0xd0, 0x4f, 0x31, 0x7f, 0x2d, 0x68, 0x9c, 0x12, 0x3c, 0x98, 0x2b, 0xcc, + 0x77, 0xb1, 0xac, 0x11, 0xe0, 0x4f, 0x74, 0x5a, 0x94, 0x9d, 0xf5, 0x28, 0x8a, 0x98, 0xb7, 0xfe, + 0xaa, 0x61, 0xca, 0xd0, 0xe6, 0xf6, 0x06, 0x17, 0x94, 0x76, 0x71, 0xb6, 0x62, 0xdc, 0xb4, 0xc5, + 0x59, 0x16, 0x9d, 0xc2, 0xa4, 0x78, 0x92, 0x2b, 0x23, 0x0a, 0x33, 0xc1, 0x07, 0xca, 0x0a, 0xfe, + 0x14, 0x37, 0x65, 0x5d, 0x33, 0x6d, 0x1a, 0x01, 0xe5, 0x48, 0x55, 0xa5, 0x11, 0x00, 0x0e, 0x02, + 0x7b, 0x0f, 0xec, 0x9c, 0x8c, 0xb5, 0x89, 0x2b, 0x7e, 0x04, 0x03, 0x89, 0xc9, 0x34, 0x6d, 0xd0, + 0x40, 0x27, 0x60, 0x18, 0x57, 0xf9, 0xba, 0x40, 0x96, 0xc0, 0x36, 0x73, 0x15, 0x25, 0x3d, 0x38, + 0x4b, 0x84, 0x57, 0x51, 0x84, 0xb3, 0xfc, 0x5c, 0x53, 0x37, 0x00, 0xc9, 0x27, 0x91, 0xcf, 0xa7, + 0x98, 0x57, 0xc2, 0x57, 0xad, 0x1f, 0xa8, 0x4c, 0xd9, 0xa6, 0x3a, 0xa8, 0x1d, 0xe0, 0x31, 0xf2, + 0x0a, 0x5c, 0x24, 0xdf, 0x4d, 0x28, 0x33, 0x21, 0x61, 0x43, 0x99, 0x90, 0xdd, 0x14, 0x73, 0xc4, + 0x3b, 0x95, 0x3d, 0xbd, 0xd2, 0x9b, 0xbd, 0xb8, 0x47, 0x3c, 0xa7, 0xb2, 0xd5, 0xae, 0x58, 0xca, + 0x7e, 0x90, 0xe7, 0x1d, 0x82, 0x2f, 0xa5, 0x9a, 0x24, 0x32, 0xe1, 0x55, 0x83, 0x66, 0xba, 0x0a, + 0x22, 0xcd, 0x70, 0xe4, 0x25, 0xd3, 0x52, 0x12, 0x6d, 0x08, 0xd9, 0xaa, 0x21, 0xf5, 0x3a, 0x87, + 0xb9, 0x9b, 0x4e, 0xea, 0xe0, 0x31, 0xeb, 0xa8, 0x17, 0xe4, 0x9a, 0x8d, 0x64, 0x96, 0xff, 0x50, + 0x71, 0x30, 0x2b, 0xfa, 0x7f, 0x68, 0x4c, 0x09, 0x3d, 0x0d, 0x50, 0x85, 0xf4, 0x1a, 0x2f, 0x6c, + 0x94, 0x33, 0x6a, 0x59, 0x15, 0xb4, 0xd0, 0x33, 0xd8, 0xd2, 0xcd, 0x5e, 0x2e, 0x76, 0x69, 0xa5, + 0xee, 0xbe, 0x34, 0x3c, 0x23, 0x73, 0x26, 0x18, 0xd5, 0xc1, 0x00, 0xb0, 0x02, 0xec, 0x6b, 0xea, + 0xee, 0xcd, 0x9e, 0x71, 0x5d, 0x19, 0xe9, 0xd9, 0x33, 0x6e, 0xb0, 0xd1, 0xb6, 0xbe, 0x53, 0xcc, + 0x0d, 0x6d, 0xed, 0x82, 0x0c, 0x6d, 0x05, 0xe0, 0xde, 0x04, 0x74, 0x1e, 0x46, 0xea, 0x97, 0x3c, + 0x0f, 0x74, 0xc2, 0xf7, 0xe1, 0xf4, 0x42, 0xb8, 0x00, 0xe8, 0xfb, 0x68, 0x4f, 0x30, 0x2b, 0x28, + 0x81, 0x28, 0x53, 0x5e, 0x9a, 0x8a, 0x7e, 0xf9, 0xc7, 0x96, 0xae, 0xe3, 0xee, 0xf9, 0x31, 0x7c, + 0x80, 0xa5, 0xb6, 0x0b, 0x77, 0x4b, 0xea, 0x2e, 0x4f, 0x6c, 0xea, 0x43, 0x70, 0x6a, 0x90, 0xab, + 0x3b, 0xbf, 0xde, 0x2c, 0xe4, 0x7d, 0xca, 0xb4, 0xd5, 0x6a, 0x68, 0xec, 0xd6, 0x05, 0x3a, 0x8c, + 0xf4, 0xb8, 0xc2, 0x61, 0xbb, 0xe3, 0x38, 0xd6, 0x95, 0xfe, 0xb9, 0xce, 0x5b, 0xa2, 0xad, 0xbc, + 0xd1, 0x72, 0x82, 0x77, 0x26, 0xbe, 0xde, 0xa6, 0x33, 0xe9, 0x7e, 0x53, 0xb4, 0xe0, 0x7f, 0xc8, + 0x1e, 0x84, 0x99, 0x49, 0xff, 0x97, 0x8b, 0xd2, 0xff, 0xfa, 0x49, 0xe1, 0xd1, 0x55, 0xe8, 0x5e, + 0x11, 0x6d, 0xfc, 0x3f, 0x67, 0x00, 0x9c, 0xcc, 0xf1, 0x98, 0x43, 0xa7, 0x8d, 0x7a, 0xf2, 0x70, + 0x23, 0x2d, 0xeb, 0xef, 0x5b, 0xa2, 0x83, 0x70, 0x31, 0x6b, 0xbf, 0x4b, 0x6d, 0xe3, 0x24, 0xce, + 0x3a, 0x60, 0x85, 0x65, 0x76, 0x96, 0xba, 0x17, 0xa2, 0xe9, 0x47, 0x79, 0x16, 0x0f, 0xce, 0x03, + 0x4e, 0x8e, 0xd2, 0xf4, 0x33, 0x33, 0xf7, 0xd8, 0x93, 0x4d, 0x37, 0x2d, 0x3d, 0xe4, 0x61, 0x56, + 0x52, 0x40, 0x03, 0x49, 0xec, 0x33, 0xd9, 0x0d, 0x61, 0xdb, 0x92, 0x65, 0x28, 0x11, 0x8e, 0xe7, + 0xc7, 0xca, 0x1b, 0x84, 0x01, 0x20, 0x2c, 0xc9, 0x5b, 0xbd, 0x61, 0x40, 0xc7, 0x73, 0x4b, 0x1a, + 0x04, 0xc6, 0x62, 0x30, 0x81, 0x52, 0x60, 0xe0, 0x92, 0x2f, 0x44, 0x81, 0x33, 0x41, 0xb5, 0xb8, + 0x4c, 0xdc, 0xeb, 0xf6, 0xaa, 0xbb, 0xec, 0x6d, 0xd3, 0x14, 0x2e, 0x5c, 0x3e, 0xb1, 0xf5, 0x82, + 0x15, 0xbd, 0x99, 0x3e, 0xb5, 0x08, 0x60, 0x27, 0xd5, 0xaa, 0x4e, 0x84, 0x65, 0x66, 0x93, 0x9b, + 0x2e, 0x01, 0x2d, 0x68, 0x0d, 0x08, 0x39, 0xa9, 0xd1, 0x72, 0x91, 0xad, 0xa2, 0xe7, 0xbb, 0x54, + 0x15, 0xe5, 0x3e, 0x4b, 0x60, 0x5a, 0x98, 0xa8, 0x36, 0x4b, 0xcd, 0x20, 0xe2, 0x7f, 0x47, 0xc7, + 0xa8, 0xd9, 0x90, 0xad, 0x37, 0x79, 0xbe, 0xc0, 0x4e, 0x52, 0x5c, 0xdc, 0x5a, 0x09, 0xd1, 0xfd, + 0xd0, 0x89, 0xa8, 0x9d, 0x72, 0xa9, 0xdb, 0x15, 0xf3, 0x6a, 0x03, 0xe8, 0x3f, 0xeb, 0x7a, 0x28, + 0x17, 0xfa, 0x3e, 0x14, 0x17, 0x8a, 0xfb, 0xe5, 0xfc, 0x42, 0x75, 0xe6, 0x71, 0x87, 0x6a, 0x7d, + 0xab, 0x61, 0xf6, 0x69, 0x6f, 0x3d, 0xdc, 0x65, 0x78, 0x3f, 0x83, 0xf3, 0x2a, 0x5e, 0x01, 0x68, + 0xfe, 0x81, 0x0c, 0xed, 0x20, 0x74, 0x59, 0xf7, 0x67, 0x90, 0x81, 0xc5, 0x7c, 0x3e, 0x76, 0x16, + 0x30, 0xd0, 0x20, 0x58, 0x76, 0x0c, 0x9f, 0x53, 0xf9, 0x24, 0x55, 0x41, 0xbb, 0x3a, 0x0c, 0x7e, + 0xc2, 0xa0, 0x8c, 0x9a, 0xf5, 0x7d, 0xd5, 0xd8, 0x0c, 0xe8, 0x55, 0x39, 0x2a, 0x27, 0x22, 0xbb, + 0xba, 0xef, 0xa2, 0x0a, 0xe7, 0x55, 0x66, 0x89, 0xa5, 0x6e, 0x4d, 0x8f, 0xc7, 0x28, 0xae, 0x21, + 0xff, 0x84, 0x0c, 0x58, 0xf7, 0xae, 0x98, 0x57, 0x1f, 0xd0, 0x52, 0xf0, 0x63, 0x0a, 0xd8, 0x4a, + 0x5e, 0x52, 0xe4, 0x21, 0xe2, 0x52, 0xae, 0x8a, 0xc1, 0x54, 0x66, 0x32, 0xc4, 0xbc, 0x7b, 0x24, + 0x2e, 0x16, 0x4f, 0xe1, 0xd1, 0x38, 0x7d, 0xb4, 0x07, 0xa2, 0x27, 0xa7, 0x5f, 0x30, 0x92, 0xe2, + 0xaf, 0x4b, 0x97, 0xa1, 0x2e, 0xa2, 0x98, 0xab, 0x57, 0x1b, 0x2a, 0xd8, 0xbe, 0x5e, 0x2c, 0x50, + 0x78, 0x52, 0x0e, 0xb7, 0x50, 0x2b, 0xa2, 0xbf, 0x87, 0x77, 0x6d, 0x40, 0x91, 0x34, 0x0a, 0x69, + 0x2e, 0x0a, 0x6e, 0xb1, 0x02, 0x51, 0x58, 0x53, 0x6b, 0xd5, 0x8b, 0xc9, 0x86, 0xa6, 0x4e, 0xd9, + 0x0e, 0xc7, 0x80, 0x02, 0xe3, 0x6a, 0xa3, 0x63, 0xcb, 0x7a, 0xa7, 0x14, 0x02, 0x6d, 0x80, 0xcb, + 0x42, 0xd9, 0x1f, 0x3f, 0x9d, 0x6c, 0xe0, 0x15, 0x22, 0xf2, 0x74, 0xd9, 0xca, 0x85, 0xaf, 0x7c, + 0x48, 0x6d, 0xeb, 0xbd, 0x52, 0xdc, 0x53, 0x5d, 0x59, 0x47, 0xa4, 0x35, 0x31, 0x39, 0xf2, 0x68, + 0x6b, 0x97, 0xbd, 0xae, 0xdd, 0x34, 0x86, 0xf0, 0x17, 0x99, 0x0c, 0x26, 0x6b, 0x3c, 0x1c, 0x07, + 0x74, 0x21, 0x1b, 0xfa, 0x8e, 0x26, 0x1c, 0x11, 0x67, 0x79, 0x0d, 0xbc, 0x15, 0x12, 0x8e, 0x07, + 0xbb, 0xa9, 0x5b, 0x59, 0x33, 0x7f, 0x18, 0x83, 0x11, 0x4d, 0xb3, 0x6c, 0x12, 0x2a, 0x21, 0x27, + 0x76, 0xe2, 0x41, 0xa2, 0xca, 0x90, 0xdb, 0xe2, 0x99, 0x29, 0xa8, 0x6f, 0x8f, 0x07, 0x45, 0x14, + 0x6c, 0xeb, 0x60, 0x75, 0x7f, 0x3c, 0x20, 0x39, 0x6f, 0x6a, 0x33, 0x9d, 0x3f, 0xb4, 0x50, 0x41, + 0xd9, 0x55, 0x25, 0x2f, 0xbb, 0xeb, 0x49, 0x12, 0xba, 0x98, 0x45, 0xc1, 0xf4, 0x0f, 0x72, 0x24, + 0xe3, 0x9e, 0xad, 0xd8, 0xa7, 0x0e, 0xf7, 0x01, 0xf3, 0x7d, 0xca, 0x8a, 0x8c, 0x6b, 0xd3, 0x57, + 0x9a, 0xcc, 0x6c, 0x6a, 0x66, 0xae, 0xb3, 0x8d, 0xdc, 0xda, 0xdd, 0x08, 0x87, 0xd1, 0x38, 0x95, + 0x1f, 0xc9, 0x23, 0xd6, 0x30, 0xf8, 0x1b, 0x6e, 0x34, 0x37, 0x9c, 0x63, 0xb1, 0x20, 0x87, 0xe8, + 0x8c, 0x3c, 0xf4, 0xca, 0xa5, 0x22, 0x08, 0xc2, 0xc4, 0xd7, 0x4e, 0x00, 0x23, 0xa3, 0xae, 0x06, + 0xd6, 0x34, 0x12, 0x51, 0x00, 0xfd, 0x84, 0xf6, 0x61, 0x0f, 0x25, 0x25, 0xec, 0x5a, 0x59, 0x83, + 0x3a, 0xf8, 0x02, 0xe0, 0x7f, 0xdb, 0x81, 0x7f, 0x20, 0xed, 0x49, 0x38, 0x56, 0xde, 0x32, 0x7f, + 0x81, 0xdf, 0xf9, 0x57, 0x3a, 0xc0, 0xb9, 0xce, 0x8b, 0xe2, 0x59, 0xf8, 0x82, 0xb0, 0x18, 0x54, + 0x52, 0x5a, 0x4f, 0x75, 0x0b, 0xeb, 0x02, 0x1b, 0x48, 0xad, 0x43, 0x46, 0xe9, 0x83, 0x70, 0x90, + 0x58, 0xbf, 0x20, 0x56, 0x68, 0x9b, 0x1b, 0x3c, 0x5e, 0x7e, 0x0e, 0x85, 0x37, 0x37, 0x19, 0x90, + 0xe6, 0xce, 0xfc, 0xcb, 0xc8, 0x99, 0xa0, 0xdf, 0xaa, 0x92, 0x97, 0x46, 0x66, 0xbe, 0x9d, 0x15, + 0xc6, 0x5d, 0xb2, 0x8a, 0xe4, 0x91, 0x15, 0xcb, 0xb6, 0xca, 0x4d, 0xbc, 0x0b, 0x02, 0xa3, 0x33, + 0xa9, 0xac, 0x7b, 0xb3, 0xf0, 0xcb, 0x1a, 0x4d, 0x71, 0x2b, 0x8d, 0xf9, 0xb5, 0x57, 0x1d, 0x4e, + 0x61, 0x10, 0x3b, 0x23, 0x7c, 0x07, 0xa6, 0xae, 0x7c, 0x1e, 0xd6, 0x01, 0xc7, 0xf5, 0x37, 0x85, + 0xaf, 0x45, 0xf8, 0xfe, 0x4e, 0x55, 0xd2, 0x36, 0x77, 0x1e, 0x66, 0x2e, 0x39, 0x63, 0x25, 0x11, + 0x8c, 0x9d, 0x64, 0x9f, 0x5c, 0x09, 0x58, 0xaf, 0x03, 0x33, 0x7b, 0x2f, 0x70, 0x94, 0xb2, 0xe3, + 0xfc, 0x84, 0x1e, 0x47, 0x46, 0x25, 0xf6, 0xc1, 0x08, 0x7e, 0xe7, 0x45, 0xa7, 0xc1, 0x18, 0x64, + 0xc2, 0x8b, 0x87, 0x8a, 0x61, 0x70, 0x61, 0x68, 0x24, 0x89, 0x40, 0x80, 0x54, 0xc1, 0x49, 0x8f, + 0x0d, 0x65, 0x3c, 0x60, 0xbe, 0xad, 0x90, 0x01, 0x01, 0xd7, 0x40, 0xbf, 0xfb, 0x98, 0xcf, 0xac, + 0x0a, 0x0f, 0x82, 0x0c, 0xee, 0x2b, 0xb7, 0x02, 0x3d, 0x65, 0x24, 0x93, 0xed, 0x31, 0x15, 0x3e, + 0xad, 0x7f, 0x6a, 0xf0, 0x1d, 0x2c, 0xec, 0xaa, 0x86, 0x73, 0xe5, 0xc4, 0x06, 0x70, 0xb2, 0x1f, + 0x60, 0x10, 0x6b, 0x6e, 0x4d, 0xd9, 0x3b, 0xc0, 0x47, 0x84, 0xda, 0x48, 0xb3, 0xda, 0x81, 0xc9, + 0x05, 0xea, 0xcd, 0xf0, 0xf6, 0x12, 0xb4, 0x35, 0xec, 0x27, 0x81, 0x87, 0x5c, 0xfd, 0x4a, 0x66, + 0x67, 0x5e, 0x77, 0xc4, 0x15, 0xbf, 0xe3, 0x93, 0x8e, 0x85, 0x69, 0x3b, 0x26, 0xbf, 0x09, 0x63, + 0x8f, 0x8e, 0xda, 0xdd, 0x5d, 0x4c, 0xd5, 0xed, 0xd0, 0x6e, 0x68, 0x63, 0x3b, 0x3f, 0xc2, 0xc6, + 0xc0, 0xfa, 0x99, 0xf1, 0xbc, 0xf2, 0xfd, 0x8a, 0xdb, 0x9d, 0xab, 0xdd, 0xee, 0xfc, 0x31, 0xdb, + 0x5d, 0x98, 0xbd, 0x5d, 0xde, 0xd9, 0x8d, 0x52, 0x20, 0x8e, 0x19, 0x93, 0xdd, 0x48, 0x82, 0x4a, + 0x0c, 0x76, 0xc7, 0x60, 0x7a, 0x27, 0xa4, 0x94, 0xe9, 0x5f, 0x79, 0x4e, 0xeb, 0x37, 0x0a, 0x99, + 0x9b, 0x69, 0xab, 0x0a, 0x67, 0xbf, 0x53, 0x0d, 0x7b, 0x39, 0x4d, 0xd0, 0x2c, 0x38, 0xb5, 0x79, + 0x18, 0x06, 0x96, 0x32, 0x1c, 0x12, 0x91, 0x59, 0xc3, 0x83, 0x3f, 0xa2, 0x76, 0x34, 0x3b, 0x09, + 0xf7, 0xd2, 0x23, 0x27, 0x96, 0x2a, 0x33, 0x9a, 0x45, 0xd0, 0xd4, 0xed, 0x00, 0xee, 0xdb, 0x15, + 0x93, 0x2e, 0xd0, 0x3a, 0xde, 0x74, 0xb2, 0xaa, 0x9b, 0x2a, 0xf8, 0xf7, 0x2b, 0xe0, 0x82, 0xbc, + 0x7a, 0x22, 0x48, 0x60, 0xbc, 0x82, 0xc9, 0xac, 0x5d, 0xe6, 0xc1, 0xfd, 0x8a, 0xf5, 0x69, 0xb1, + 0x6a, 0xc5, 0x6a, 0x26, 0x8c, 0x07, 0x21, 0x98, 0xca, 0x91, 0xce, 0x3b, 0x51, 0x52, 0xb6, 0x12, + 0x9f, 0x36, 0xf4, 0x3b, 0xb8, 0x2c, 0xa9, 0x0e, 0x66, 0x5a, 0xea, 0x14, 0x94, 0x6d, 0x76, 0x8d, + 0xd5, 0x02, 0x2e, 0x94, 0x50, 0x4c, 0x72, 0xe9, 0x0d, 0x56, 0x82, 0x1d, 0x0b, 0x58, 0x33, 0xb6, + 0x09, 0x84, 0x0e, 0xbc, 0x17, 0xad, 0xb7, 0xcc, 0xe8, 0x14, 0xdb, 0x1c, 0xd7, 0x47, 0x23, 0x20, + 0xce, 0xa5, 0x37, 0x3a, 0x09, 0xbf, 0x1a, 0x24, 0x5a, 0xe5, 0x91, 0x6a, 0x8e, 0xd4, 0xb5, 0x36, + 0xab, 0x42, 0x58, 0x65, 0xb9, 0xf5, 0xdb, 0xc5, 0xe0, 0x17, 0x5c, 0xc4, 0x8f, 0x42, 0xac, 0x6a, + 0xb3, 0x27, 0x9c, 0x74, 0x3e, 0x10, 0xab, 0x23, 0x73, 0x40, 0xf9, 0xa8, 0xaf, 0xf4, 0x6a, 0x16, + 0xf5, 0xcc, 0x5f, 0xdd, 0xf7, 0xc4, 0x8a, 0xf9, 0x1b, 0x6f, 0x0b, 0x56, 0x13, 0x6d, 0x13, 0xac, + 0x99, 0xe5, 0x58, 0xd5, 0xef, 0x40, 0x38, 0xef, 0xf0, 0x4b, 0x85, 0x5c, 0x15, 0x58, 0x63, 0xa4, + 0xbb, 0x48, 0x23, 0xbe, 0x21, 0xcb, 0x58, 0xe0, 0xf2, 0x0c, 0xad, 0xae, 0x21, 0xfc, 0xaf, 0x7e, + 0x43, 0x3f, 0x50, 0x15, 0xe9, 0x56, 0x3b, 0x2f, 0x8b, 0xcb, 0x53, 0x66, 0xa8, 0x0e, 0xf4, 0x88, + 0x37, 0xcd, 0xde, 0xe2, 0x4b, 0xa6, 0x78, 0x2b, 0x8e, 0x4e, 0x23, 0xc8, 0x1a, 0x98, 0x36, 0xed, + 0xd1, 0xde, 0x5e, 0xe0, 0x8f, 0xe4, 0x43, 0xf6, 0x88, 0x0b, 0xac, 0xc0, 0x8e, 0x01, 0xfe, 0x6a, + 0xeb, 0x67, 0xce, 0x8a, 0xec, 0x2b, 0xe2, 0xb9, 0x3d, 0xae, 0x28, 0xdb, 0x47, 0x60, 0x96, 0xec, + 0xca, 0x34, 0x36, 0x9e, 0x5f, 0x9c, 0x62, 0x3c, 0x8b, 0xf8, 0xc8, 0x17, 0x05, 0x19, 0x32, 0xb2, + 0x08, 0x77, 0x31, 0x08, 0xe7, 0x92, 0xad, 0x9a, 0xf4, 0x21, 0xa7, 0x33, 0x2a, 0x65, 0x77, 0xeb, + 0x3f, 0x95, 0x5b, 0x74, 0xcc, 0x42, 0x53, 0xb2, 0x2b, 0x75, 0xfb, 0x64, 0xec, 0xba, 0xf8, 0xd6, + 0x53, 0xf7, 0x05, 0x2f, 0x66, 0x7b, 0xe0, 0xe4, 0xf9, 0xad, 0xde, 0x29, 0x30, 0xf4, 0x0a, 0x1f, + 0xbb, 0x9f, 0x88, 0xd5, 0xc2, 0x00, 0x25, 0x73, 0xf9, 0xee, 0x9a, 0x29, 0xdf, 0x62, 0x1a, 0x64, + 0xb5, 0x12, 0xa0, 0xa0, 0xd5, 0x18, 0x8f, 0xa8, 0x8f, 0x88, 0x7b, 0x7d, 0xdf, 0x16, 0x6f, 0x9e, + 0x80, 0x28, 0xb8, 0xe6, 0x45, 0x66, 0x27, 0xb0, 0xf0, 0xf3, 0x53, 0x17, 0x26, 0xbb, 0xc8, 0x96, + 0x07, 0xe0, 0xad, 0x07, 0x09, 0xea, 0xd8, 0x8c, 0x48, 0xbe, 0x50, 0xab, 0xd6, 0x6f, 0x15, 0x5e, + 0x61, 0xcd, 0x58, 0x99, 0xf1, 0xf9, 0xb6, 0x58, 0x50, 0xe2, 0xa1, 0xee, 0xe3, 0xb5, 0xde, 0x89, + 0x17, 0x2b, 0x16, 0x76, 0x5f, 0x15, 0xf3, 0xfc, 0xaf, 0x69, 0x4c, 0x83, 0x4b, 0x18, 0xe0, 0x2a, + 0x75, 0x09, 0xff, 0x4d, 0xb9, 0x17, 0x46, 0xed, 0x6a, 0xdd, 0xf3, 0x62, 0xdd, 0x9b, 0xcd, 0x95, + 0x41, 0x07, 0x46, 0xf0, 0xa0, 0xf3, 0xd6, 0x1c, 0x1a, 0xf6, 0xb3, 0x14, 0xb8, 0xd2, 0x99, 0x8b, + 0x78, 0x29, 0xf9, 0x9b, 0x91, 0x1b, 0xe7, 0xba, 0xa2, 0xa7, 0xfc, 0xe2, 0x97, 0xc4, 0x0b, 0xa0, + 0x0b, 0xa9, 0xc3, 0xc6, 0xc9, 0x6a, 0x8e, 0x59, 0x21, 0x8c, 0x82, 0x71, 0x2e, 0xd7, 0x5d, 0x13, + 0xaf, 0x64, 0x6a, 0x19, 0xfb, 0xab, 0x49, 0x85, 0x7e, 0xc3, 0x99, 0xbe, 0x84, 0x8d, 0xd6, 0x0b, + 0xe2, 0x62, 0x2c, 0x87, 0xfe, 0x88, 0xfb, 0x10, 0x6d, 0xa7, 0x1f, 0x8e, 0x55, 0x05, 0x54, 0xbd, + 0xa8, 0xf8, 0x23, 0xad, 0x72, 0x76, 0xee, 0xcc, 0x68, 0x75, 0xad, 0x64, 0x10, 0xb2, 0x14, 0x44, + 0xe6, 0x3b, 0xcf, 0x95, 0x9b, 0x78, 0x5b, 0xb9, 0x99, 0xcb, 0x4a, 0xbf, 0xab, 0x85, 0x37, 0x6f, + 0xd9, 0x13, 0xde, 0x79, 0x6a, 0xf7, 0x86, 0x63, 0x21, 0x02, 0x8d, 0x57, 0xbd, 0xcf, 0x4f, 0x7d, + 0x42, 0xb7, 0xc8, 0x0f, 0xe6, 0xae, 0xdd, 0xb0, 0xbe, 0xdb, 0x54, 0x9e, 0xc1, 0x4c, 0xca, 0x6b, + 0x33, 0x86, 0xdb, 0xb3, 0x1a, 0x80, 0xd5, 0x5b, 0x8c, 0x63, 0xa1, 0x9e, 0xb4, 0xdd, 0xf7, 0xf0, + 0x54, 0xed, 0xbe, 0xc0, 0x88, 0xc3, 0x10, 0x2b, 0x1f, 0x7b, 0x2a, 0xd5, 0x31, 0x87, 0x70, 0x79, + 0xc8, 0x19, 0x38, 0x58, 0x15, 0x50, 0xf1, 0x2f, 0x5c, 0xec, 0x98, 0xc2, 0xd9, 0x44, 0x45, 0x51, + 0xe8, 0xeb, 0xb8, 0xa1, 0xf2, 0x57, 0x9a, 0xd6, 0xaf, 0x34, 0x54, 0xf0, 0xbb, 0x73, 0x07, 0x4d, + 0xe1, 0x27, 0x00, 0x62, 0x77, 0x3c, 0x1c, 0x3a, 0xa0, 0xfb, 0x36, 0x44, 0xa7, 0x82, 0x5f, 0xdf, + 0xae, 0x97, 0x7a, 0xd3, 0x17, 0x95, 0xb7, 0x7b, 0xca, 0xb6, 0xf6, 0xff, 0xce, 0xe5, 0xac, 0x04, + 0xb8, 0xf6, 0x94, 0x1e, 0x88, 0xf3, 0x68, 0xe7, 0x6d, 0x64, 0x00, 0xd8, 0x29, 0x5c, 0xe0, 0x67, + 0x27, 0xf5, 0x46, 0xaf, 0x1e, 0x62, 0xaf, 0x34, 0x8e, 0x47, 0x51, 0x66, 0xc5, 0xff, 0xc9, 0x51, + 0x6c, 0x2b, 0xf7, 0x64, 0xe7, 0x4e, 0xde, 0x83, 0x9d, 0xf1, 0x4e, 0x53, 0x54, 0x47, 0x0a, 0x26, + 0x36, 0x90, 0x03, 0xe3, 0x48, 0x39, 0x4a, 0x1f, 0x28, 0x9f, 0xb1, 0x16, 0x62, 0x6d, 0xeb, 0xfe, + 0xef, 0x37, 0xb2, 0xeb, 0xb3, 0x55, 0x6a, 0xfe, 0xd7, 0xeb, 0x37, 0xb9, 0xf4, 0xd7, 0xd9, 0xad, + 0x11, 0x97, 0xec, 0xb6, 0x1c, 0x03, 0xe4, 0x47, 0x14, 0x9f, 0x7f, 0x6d, 0x88, 0x13, 0x22, 0x3a, + 0xa6, 0xeb, 0x9f, 0xfd, 0xb1, 0x5c, 0xa6, 0xf2, 0xd6, 0x29, 0xe3, 0x81, 0xec, 0x89, 0x91, 0xf4, + 0x70, 0x52, 0xf1, 0x5b, 0xf7, 0x03, 0xd1, 0xa9, 0x8e, 0xd6, 0x1f, 0x6e, 0x1b, 0x49, 0x61, 0x11, + 0xc3, 0xae, 0xfe, 0x3f, 0x56, 0xf9, 0xdc, 0x3c, 0x29, 0xb9, 0x0d, 0x4a, 0x70, 0x17, 0x6c, 0x7a, + 0x20, 0x51, 0xb4, 0x86, 0x13, 0x9d, 0xea, 0x5c, 0xa0, 0x0c, 0x74, 0x62, 0x1b, 0x61, 0xe0, 0x5c, + 0xe7, 0x26, 0x44, 0xdc, 0xe0, 0xd4, 0xd1, 0x74, 0xed, 0x78, 0x5c, 0xee, 0xcd, 0x02, 0xd8, 0xe3, + 0xff, 0x75, 0xef, 0x88, 0x79, 0x85, 0x81, 0xd3, 0xcd, 0x0d, 0x5d, 0x44, 0x71, 0x0e, 0x07, 0x76, + 0x84, 0x4a, 0x78, 0x98, 0xe4, 0x71, 0x66, 0x92, 0x7a, 0x9e, 0x3c, 0xd4, 0xe3, 0xf6, 0x93, 0x6b, + 0x57, 0x95, 0xdf, 0xf8, 0x2a, 0x2b, 0x1d, 0xb6, 0xcb, 0x61, 0x10, 0x84, 0x47, 0x98, 0x56, 0x02, + 0xb5, 0x3f, 0x25, 0x03, 0xae, 0xaa, 0xfb, 0xd5, 0xb9, 0xc7, 0xb4, 0x51, 0x18, 0x3e, 0x33, 0xf1, + 0xeb, 0x65, 0xce, 0xa4, 0x13, 0x9c, 0x7b, 0x09, 0x43, 0xc2, 0xdc, 0x62, 0x15, 0xe3, 0x23, 0x4e, + 0xd8, 0x94, 0x67, 0xd6, 0xe2, 0xbb, 0x24, 0x56, 0x7c, 0xd4, 0x01, 0x6a, 0x6e, 0xf1, 0xcf, 0x03, + 0xdc, 0xd0, 0x00, 0x33, 0x63, 0x91, 0x01, 0x7d, 0x00, 0x8e, 0x53, 0xd9, 0x2e, 0x72, 0xb4, 0xe2, + 0xb1, 0x27, 0x3b, 0x6b, 0x51, 0x2d, 0x35, 0x15, 0x23, 0xd3, 0xd4, 0xc9, 0x50, 0xbd, 0x55, 0x3e, + 0xf2, 0x79, 0xeb, 0x2a, 0xe7, 0x1d, 0x37, 0xb7, 0x61, 0xaf, 0x1f, 0x51, 0xe3, 0xdc, 0xa3, 0xbd, + 0x0d, 0x2e, 0x86, 0x71, 0xb6, 0x2f, 0x29, 0x65, 0xc4, 0xac, 0x5d, 0x8e, 0x1b, 0x6b, 0x56, 0xd4, + 0x92, 0x06, 0xb1, 0x24, 0xe7, 0xd6, 0x6d, 0xe3, 0x7c, 0x2c, 0xa7, 0xe0, 0x8e, 0x93, 0x13, 0x46, + 0xcf, 0x9c, 0x21, 0x2a, 0x1f, 0x27, 0xd9, 0xfd, 0xc2, 0x90, 0x93, 0xbd, 0x3c, 0xbb, 0xe8, 0x54, + 0x67, 0x24, 0x36, 0x8d, 0xc7, 0x42, 0xb0, 0x92, 0xeb, 0x11, 0x9c, 0x72, 0xef, 0x9b, 0x0e, 0x1b, + 0xca, 0xb7, 0xef, 0x82, 0x97, 0x8a, 0x4d, 0x4d, 0x94, 0x62, 0xa1, 0x7f, 0x99, 0xe1, 0x2d, 0x3e, + 0x31, 0xa1, 0x7e, 0x42, 0xff, 0x9b, 0x12, 0x13, 0x53, 0xd4, 0xfe, 0xd4, 0xd4, 0x4d, 0xf5, 0x70, + 0xd8, 0x66, 0xb8, 0xc6, 0x4e, 0x9a, 0xf5, 0x35, 0x33, 0x7b, 0x5e, 0xc0, 0x91, 0xf1, 0x64, 0x2a, + 0x2e, 0x4b, 0x74, 0x2b, 0xb8, 0xec, 0xac, 0xcf, 0x8e, 0xe3, 0x75, 0x4b, 0x9c, 0x33, 0x22, 0xcc, + 0x7b, 0x0f, 0xc1, 0x7d, 0x23, 0x2f, 0xdd, 0x1f, 0xa2, 0x23, 0xc7, 0x67, 0xf3, 0x65, 0x33, 0x0d, + 0xf2, 0x89, 0x33, 0xf2, 0xd3, 0xc9, 0xe3, 0x9d, 0x07, 0xea, 0x9d, 0x4f, 0x21, 0xd0, 0xc2, 0xbf, + 0x86, 0x42, 0xdf, 0x29, 0xab, 0xc1, 0x5d, 0xa6, 0x3f, 0x6f, 0x46, 0x73, 0xd8, 0x30, 0x10, 0xc6, + 0x40, 0xcf, 0x83, 0xd0, 0x75, 0x82, 0x4d, 0x6a, 0xc5, 0xd3, 0x3d, 0x6b, 0x70, 0xb5, 0x55, 0x6f, + 0x9e, 0xf9, 0x27, 0x4a, 0x1a, 0x59, 0xcf, 0x37, 0xc6, 0x92, 0x59, 0xef, 0x78, 0xd6, 0x18, 0x75, + 0x60, 0x86, 0xad, 0xd3, 0xc0, 0x4f, 0x95, 0x97, 0x99, 0xf0, 0x30, 0x47, 0x80, 0xa5, 0x1a, 0x6c, + 0x1d, 0x64, 0x62, 0x38, 0xbb, 0x41, 0x4d, 0x86, 0xd6, 0xc8, 0x8c, 0xf5, 0x37, 0xa5, 0xa3, 0xd1, + 0x15, 0x37, 0x02, 0x7c, 0xf7, 0xb2, 0x6f, 0xec, 0x75, 0x1b, 0x68, 0xd8, 0x91, 0x7d, 0x51, 0x3c, + 0x5b, 0x9e, 0x53, 0xc0, 0x47, 0x95, 0x07, 0xeb, 0xb1, 0x99, 0x34, 0xa8, 0xe0, 0x9b, 0xba, 0xb3, + 0x7a, 0xe4, 0xcc, 0xb3, 0x1f, 0x16, 0x12, 0x5b, 0x70, 0x25, 0x0c, 0x76, 0xad, 0x9b, 0x4b, 0x13, + 0x2a, 0xeb, 0xcf, 0xde, 0x49, 0x8b, 0x7b, 0xb5, 0x4c, 0xca, 0xb5, 0x39, 0xbb, 0xd1, 0x3b, 0x19, + 0x86, 0x1e, 0x0f, 0x52, 0x17, 0x49, 0xf7, 0x5d, 0xb1, 0x6c, 0xfc, 0x9c, 0x7a, 0x4a, 0xd9, 0xdf, + 0x13, 0x23, 0x6c, 0x7a, 0x4f, 0x6d, 0xeb, 0xb2, 0x29, 0x07, 0xd8, 0x1c, 0xa6, 0x79, 0xe5, 0x31, + 0xc4, 0xc4, 0xfa, 0x83, 0xa6, 0xb9, 0xeb, 0x69, 0x53, 0x6a, 0x55, 0xcc, 0xae, 0x78, 0x2a, 0xe3, + 0xbf, 0x16, 0x0e, 0xb5, 0xd7, 0x77, 0x7a, 0x27, 0x83, 0xdb, 0x2b, 0x7f, 0xe9, 0x7e, 0xa7, 0x21, + 0xce, 0x95, 0x07, 0x51, 0x47, 0x50, 0xb5, 0xb0, 0x20, 0x10, 0x5c, 0x27, 0xa2, 0xbf, 0x48, 0x44, + 0xa3, 0xc6, 0xdf, 0xba, 0x02, 0x36, 0x51, 0x0f, 0x84, 0x43, 0x09, 0x00, 0xa3, 0xa3, 0x06, 0xa7, + 0xf7, 0xc3, 0x38, 0x46, 0xe3, 0x96, 0xff, 0x99, 0x2b, 0xb8, 0xa4, 0xa0, 0x67, 0x22, 0xd0, 0x77, + 0x68, 0x52, 0xe6, 0xf4, 0x5f, 0xac, 0x42, 0x3b, 0x4e, 0x3a, 0x54, 0xd5, 0xd9, 0xad, 0x4b, 0xa5, + 0xbe, 0xc7, 0x3b, 0x43, 0xb8, 0xea, 0x6e, 0x38, 0x42, 0x3b, 0x61, 0x1d, 0x9a, 0xd5, 0x2d, 0xf3, + 0x4b, 0xe7, 0x86, 0x58, 0x92, 0xea, 0xb7, 0x76, 0xd4, 0x2e, 0xf7, 0xa6, 0xcf, 0xed, 0xe9, 0x1f, + 0xdd, 0x97, 0xc4, 0xa2, 0xfe, 0x77, 0x96, 0x28, 0xcd, 0x7a, 0x4a, 0x4d, 0x95, 0xfe, 0xe7, 0x85, + 0x17, 0x53, 0xbb, 0xf4, 0x06, 0xe4, 0x81, 0xdf, 0x8f, 0xc1, 0x9f, 0x06, 0x11, 0x3b, 0x60, 0xd5, + 0xde, 0xf9, 0x50, 0x9c, 0xc1, 0x97, 0x26, 0x70, 0x4e, 0x01, 0x7f, 0x53, 0x84, 0x5c, 0xed, 0x1d, + 0xbb, 0xb6, 0xf7, 0x80, 0x16, 0xaa, 0x71, 0x6c, 0x68, 0xc7, 0x62, 0xa6, 0x02, 0x63, 0x2b, 0xa8, + 0xfd, 0x09, 0xdf, 0xa4, 0xee, 0x4d, 0xb1, 0x5a, 0x9c, 0x8f, 0xcf, 0x58, 0x48, 0x64, 0xcd, 0xbc, + 0x48, 0x69, 0x95, 0xf5, 0x7b, 0x0d, 0x53, 0x8f, 0x14, 0x08, 0xd9, 0x4d, 0xc3, 0x08, 0x0d, 0x1e, + 0xfa, 0x10, 0xf8, 0x92, 0x8f, 0x9b, 0x8e, 0xec, 0x40, 0xee, 0x29, 0x51, 0xec, 0xbc, 0x8f, 0xe6, + 0x36, 0x8c, 0xd0, 0xef, 0xd2, 0x77, 0xed, 0xb5, 0xde, 0xf1, 0xd0, 0x7a, 0xf8, 0xef, 0xf5, 0x28, + 0xea, 0xbe, 0x26, 0x16, 0xd4, 0x3f, 0x2b, 0xd1, 0xb5, 0x49, 0x3c, 0x53, 0xfa, 0x1f, 0x85, 0xee, + 0x5f, 0x65, 0x7b, 0x36, 0x9c, 0x20, 0xa0, 0xba, 0xe1, 0x24, 0xc1, 0xd7, 0x8e, 0x10, 0xd6, 0xa3, + 0x20, 0x35, 0x74, 0x79, 0xc5, 0xc5, 0xae, 0x33, 0x30, 0x0e, 0x5e, 0xf6, 0x44, 0x08, 0x53, 0xfd, + 0x5c, 0x6c, 0x70, 0x63, 0x37, 0x17, 0x4d, 0x35, 0xb6, 0xef, 0x24, 0xfb, 0xaa, 0xdc, 0x81, 0x25, + 0xff, 0xf1, 0xc8, 0xe5, 0xe6, 0x00, 0x2f, 0x7f, 0xdc, 0xe5, 0x8e, 0xfb, 0x36, 0xa0, 0x89, 0xc6, + 0xd8, 0xb9, 0xf4, 0x44, 0x95, 0x03, 0xb0, 0xa1, 0x38, 0xe0, 0x98, 0x5d, 0xf5, 0x92, 0x20, 0xe6, + 0xc8, 0x89, 0x41, 0x78, 0x52, 0xf5, 0x5a, 0x88, 0xde, 0x04, 0x91, 0xa7, 0x18, 0x8e, 0x82, 0x89, + 0xfa, 0x53, 0x5c, 0x70, 0xa6, 0xd8, 0x43, 0x00, 0x00, 0xc1, 0x9e, 0xd3, 0x2d, 0xb0, 0x71, 0x65, + 0xa2, 0x9e, 0xf9, 0x7d, 0x6d, 0x9a, 0x49, 0x27, 0x52, 0x4b, 0x1b, 0x69, 0x4c, 0xdb, 0x08, 0xdb, + 0x72, 0x2c, 0x84, 0xab, 0x89, 0xc6, 0x5f, 0xfb, 0x58, 0xb1, 0x7e, 0xd0, 0x36, 0x1b, 0x6b, 0x0d, + 0x7e, 0x16, 0xea, 0xb1, 0x3f, 0x09, 0xbe, 0x4a, 0x5c, 0x5e, 0x78, 0x45, 0x49, 0x7f, 0x5a, 0x8b, + 0xde, 0x70, 0x98, 0x7f, 0xe8, 0x82, 0xfc, 0x90, 0x30, 0xd1, 0xcd, 0x26, 0xfc, 0x68, 0x60, 0x41, + 0x43, 0x01, 0xd2, 0x30, 0x7c, 0xa1, 0xc1, 0x45, 0xfd, 0x84, 0x8d, 0x0a, 0x2e, 0x3a, 0x2b, 0xb5, + 0xa4, 0x9f, 0x9b, 0xca, 0x27, 0xf8, 0x57, 0xad, 0x10, 0x44, 0x0c, 0x42, 0x1c, 0x73, 0x1b, 0xe5, + 0x0a, 0x1a, 0x14, 0x8c, 0x56, 0x9d, 0x3e, 0x50, 0x58, 0x46, 0xb3, 0xac, 0x8b, 0x40, 0xd9, 0x0c, + 0x13, 0xdf, 0x8a, 0x7e, 0xb8, 0x77, 0xe4, 0x60, 0x9e, 0x69, 0x04, 0x4b, 0x31, 0xd5, 0xc5, 0x7f, + 0xfa, 0x0c, 0x9d, 0x27, 0xd8, 0x44, 0x3c, 0xca, 0xdc, 0x53, 0xea, 0xc1, 0x61, 0xb1, 0x60, 0x3f, + 0x52, 0xb9, 0x86, 0x67, 0x75, 0xd3, 0x26, 0xe9, 0x4c, 0x93, 0xa9, 0xe7, 0x74, 0xe1, 0x31, 0xff, + 0x62, 0xb0, 0xf7, 0x29, 0xdd, 0x6e, 0x9a, 0x7f, 0x2d, 0x1e, 0x54, 0x87, 0xe8, 0xd3, 0x80, 0x4d, + 0x7e, 0x9f, 0xaf, 0x00, 0xf6, 0x93, 0x64, 0x8c, 0x7e, 0x4e, 0xa0, 0xfe, 0x2c, 0x5a, 0x11, 0xb0, + 0x1b, 0x62, 0x30, 0x94, 0xea, 0x09, 0x4f, 0x93, 0x58, 0x5e, 0xe4, 0x9b, 0xb8, 0xfe, 0xf0, 0xf1, + 0x28, 0x20, 0x6d, 0x15, 0xa3, 0xaf, 0x3a, 0x1a, 0xe8, 0x3f, 0xda, 0x58, 0xf9, 0x50, 0x6b, 0xcd, + 0xe0, 0xf0, 0x4b, 0x8d, 0xdf, 0xec, 0x0f, 0x3e, 0x34, 0xe5, 0x53, 0xa9, 0x0e, 0xf5, 0x42, 0x00, + 0xf5, 0xa3, 0x44, 0x46, 0x47, 0x3c, 0x6c, 0xf7, 0x59, 0xaf, 0xa9, 0x64, 0x23, 0xfe, 0x15, 0x4e, + 0xf5, 0x01, 0x94, 0x8a, 0x0a, 0xc9, 0xde, 0x32, 0xab, 0xd4, 0xf7, 0x7d, 0xf7, 0xa0, 0x08, 0x92, + 0xde, 0xf8, 0xc1, 0xc5, 0xb4, 0x49, 0xa3, 0x0d, 0xb4, 0xd6, 0x5f, 0x2c, 0xba, 0xd5, 0xfc, 0x04, + 0x4e, 0xf5, 0x40, 0xce, 0x28, 0x1b, 0x99, 0xcd, 0x57, 0xcd, 0xe2, 0x63, 0x84, 0x96, 0x9e, 0x10, + 0x38, 0xa0, 0x5b, 0xf6, 0xd5, 0x23, 0x9e, 0x55, 0x08, 0x01, 0x5f, 0x98, 0x81, 0xa3, 0x96, 0x73, + 0x46, 0xee, 0x9d, 0x1f, 0x6a, 0x1d, 0x9a, 0x70, 0x3e, 0x09, 0xd5, 0x85, 0xde, 0x8e, 0x33, 0x47, + 0x47, 0x92, 0x0a, 0xc3, 0x86, 0xda, 0xb8, 0x14, 0x61, 0xe0, 0xab, 0x6c, 0x7c, 0x25, 0x75, 0x58, + 0x7a, 0x4b, 0x43, 0x09, 0x20, 0xb5, 0x42, 0x35, 0xd1, 0xcc, 0xd1, 0x9f, 0x3d, 0xc5, 0x4e, 0xdf, + 0x48, 0x25, 0xcf, 0xbf, 0xd5, 0x30, 0x6b, 0x6d, 0x53, 0x11, 0x67, 0x1b, 0x39, 0x3d, 0x01, 0x9d, + 0xe2, 0x03, 0x6d, 0xdd, 0xe9, 0x98, 0x13, 0x45, 0xd9, 0xa6, 0xdb, 0x73, 0x1f, 0x36, 0x7e, 0xb1, + 0xf1, 0x53, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xda, 0x26, 0xfc, 0xe5, 0x68, 0x56, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/content_manifest.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/content_manifest.pb.go new file mode 100644 index 00000000..f5f1ad9d --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/content_manifest.pb.go @@ -0,0 +1,289 @@ +// Code generated by protoc-gen-go. +// source: content_manifest.proto +// DO NOT EDIT! + +package protobuf + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type ContentManifestPayload struct { + Mappings []*ContentManifestPayload_FileMapping `protobuf:"bytes,1,rep,name=mappings" json:"mappings,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ContentManifestPayload) Reset() { *m = ContentManifestPayload{} } +func (m *ContentManifestPayload) String() string { return proto.CompactTextString(m) } +func (*ContentManifestPayload) ProtoMessage() {} +func (*ContentManifestPayload) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{0} } + +func (m *ContentManifestPayload) GetMappings() []*ContentManifestPayload_FileMapping { + if m != nil { + return m.Mappings + } + return nil +} + +type ContentManifestPayload_FileMapping struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + Size *uint64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"` + Flags *uint32 `protobuf:"varint,3,opt,name=flags" json:"flags,omitempty"` + ShaFilename []byte `protobuf:"bytes,4,opt,name=sha_filename" json:"sha_filename,omitempty"` + ShaContent []byte `protobuf:"bytes,5,opt,name=sha_content" json:"sha_content,omitempty"` + Chunks []*ContentManifestPayload_FileMapping_ChunkData `protobuf:"bytes,6,rep,name=chunks" json:"chunks,omitempty"` + Linktarget *string `protobuf:"bytes,7,opt,name=linktarget" json:"linktarget,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ContentManifestPayload_FileMapping) Reset() { *m = ContentManifestPayload_FileMapping{} } +func (m *ContentManifestPayload_FileMapping) String() string { return proto.CompactTextString(m) } +func (*ContentManifestPayload_FileMapping) ProtoMessage() {} +func (*ContentManifestPayload_FileMapping) Descriptor() ([]byte, []int) { + return content_manifest_fileDescriptor0, []int{0, 0} +} + +func (m *ContentManifestPayload_FileMapping) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *ContentManifestPayload_FileMapping) GetSize() uint64 { + if m != nil && m.Size != nil { + return *m.Size + } + return 0 +} + +func (m *ContentManifestPayload_FileMapping) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *ContentManifestPayload_FileMapping) GetShaFilename() []byte { + if m != nil { + return m.ShaFilename + } + return nil +} + +func (m *ContentManifestPayload_FileMapping) GetShaContent() []byte { + if m != nil { + return m.ShaContent + } + return nil +} + +func (m *ContentManifestPayload_FileMapping) GetChunks() []*ContentManifestPayload_FileMapping_ChunkData { + if m != nil { + return m.Chunks + } + return nil +} + +func (m *ContentManifestPayload_FileMapping) GetLinktarget() string { + if m != nil && m.Linktarget != nil { + return *m.Linktarget + } + return "" +} + +type ContentManifestPayload_FileMapping_ChunkData struct { + Sha []byte `protobuf:"bytes,1,opt,name=sha" json:"sha,omitempty"` + Crc *uint32 `protobuf:"fixed32,2,opt,name=crc" json:"crc,omitempty"` + Offset *uint64 `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"` + CbOriginal *uint32 `protobuf:"varint,4,opt,name=cb_original" json:"cb_original,omitempty"` + CbCompressed *uint32 `protobuf:"varint,5,opt,name=cb_compressed" json:"cb_compressed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ContentManifestPayload_FileMapping_ChunkData) Reset() { + *m = ContentManifestPayload_FileMapping_ChunkData{} +} +func (m *ContentManifestPayload_FileMapping_ChunkData) String() string { + return proto.CompactTextString(m) +} +func (*ContentManifestPayload_FileMapping_ChunkData) ProtoMessage() {} +func (*ContentManifestPayload_FileMapping_ChunkData) Descriptor() ([]byte, []int) { + return content_manifest_fileDescriptor0, []int{0, 0, 0} +} + +func (m *ContentManifestPayload_FileMapping_ChunkData) GetSha() []byte { + if m != nil { + return m.Sha + } + return nil +} + +func (m *ContentManifestPayload_FileMapping_ChunkData) GetCrc() uint32 { + if m != nil && m.Crc != nil { + return *m.Crc + } + return 0 +} + +func (m *ContentManifestPayload_FileMapping_ChunkData) GetOffset() uint64 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return 0 +} + +func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbOriginal() uint32 { + if m != nil && m.CbOriginal != nil { + return *m.CbOriginal + } + return 0 +} + +func (m *ContentManifestPayload_FileMapping_ChunkData) GetCbCompressed() uint32 { + if m != nil && m.CbCompressed != nil { + return *m.CbCompressed + } + return 0 +} + +type ContentManifestMetadata struct { + DepotId *uint32 `protobuf:"varint,1,opt,name=depot_id" json:"depot_id,omitempty"` + GidManifest *uint64 `protobuf:"varint,2,opt,name=gid_manifest" json:"gid_manifest,omitempty"` + CreationTime *uint32 `protobuf:"varint,3,opt,name=creation_time" json:"creation_time,omitempty"` + FilenamesEncrypted *bool `protobuf:"varint,4,opt,name=filenames_encrypted" json:"filenames_encrypted,omitempty"` + CbDiskOriginal *uint64 `protobuf:"varint,5,opt,name=cb_disk_original" json:"cb_disk_original,omitempty"` + CbDiskCompressed *uint64 `protobuf:"varint,6,opt,name=cb_disk_compressed" json:"cb_disk_compressed,omitempty"` + UniqueChunks *uint32 `protobuf:"varint,7,opt,name=unique_chunks" json:"unique_chunks,omitempty"` + CrcEncrypted *uint32 `protobuf:"varint,8,opt,name=crc_encrypted" json:"crc_encrypted,omitempty"` + CrcClear *uint32 `protobuf:"varint,9,opt,name=crc_clear" json:"crc_clear,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ContentManifestMetadata) Reset() { *m = ContentManifestMetadata{} } +func (m *ContentManifestMetadata) String() string { return proto.CompactTextString(m) } +func (*ContentManifestMetadata) ProtoMessage() {} +func (*ContentManifestMetadata) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{1} } + +func (m *ContentManifestMetadata) GetDepotId() uint32 { + if m != nil && m.DepotId != nil { + return *m.DepotId + } + return 0 +} + +func (m *ContentManifestMetadata) GetGidManifest() uint64 { + if m != nil && m.GidManifest != nil { + return *m.GidManifest + } + return 0 +} + +func (m *ContentManifestMetadata) GetCreationTime() uint32 { + if m != nil && m.CreationTime != nil { + return *m.CreationTime + } + return 0 +} + +func (m *ContentManifestMetadata) GetFilenamesEncrypted() bool { + if m != nil && m.FilenamesEncrypted != nil { + return *m.FilenamesEncrypted + } + return false +} + +func (m *ContentManifestMetadata) GetCbDiskOriginal() uint64 { + if m != nil && m.CbDiskOriginal != nil { + return *m.CbDiskOriginal + } + return 0 +} + +func (m *ContentManifestMetadata) GetCbDiskCompressed() uint64 { + if m != nil && m.CbDiskCompressed != nil { + return *m.CbDiskCompressed + } + return 0 +} + +func (m *ContentManifestMetadata) GetUniqueChunks() uint32 { + if m != nil && m.UniqueChunks != nil { + return *m.UniqueChunks + } + return 0 +} + +func (m *ContentManifestMetadata) GetCrcEncrypted() uint32 { + if m != nil && m.CrcEncrypted != nil { + return *m.CrcEncrypted + } + return 0 +} + +func (m *ContentManifestMetadata) GetCrcClear() uint32 { + if m != nil && m.CrcClear != nil { + return *m.CrcClear + } + return 0 +} + +type ContentManifestSignature struct { + Signature []byte `protobuf:"bytes,1,opt,name=signature" json:"signature,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ContentManifestSignature) Reset() { *m = ContentManifestSignature{} } +func (m *ContentManifestSignature) String() string { return proto.CompactTextString(m) } +func (*ContentManifestSignature) ProtoMessage() {} +func (*ContentManifestSignature) Descriptor() ([]byte, []int) { return content_manifest_fileDescriptor0, []int{2} } + +func (m *ContentManifestSignature) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +func init() { + proto.RegisterType((*ContentManifestPayload)(nil), "ContentManifestPayload") + proto.RegisterType((*ContentManifestPayload_FileMapping)(nil), "ContentManifestPayload.FileMapping") + proto.RegisterType((*ContentManifestPayload_FileMapping_ChunkData)(nil), "ContentManifestPayload.FileMapping.ChunkData") + proto.RegisterType((*ContentManifestMetadata)(nil), "ContentManifestMetadata") + proto.RegisterType((*ContentManifestSignature)(nil), "ContentManifestSignature") +} + +var content_manifest_fileDescriptor0 = []byte{ + // 409 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x8c, 0x91, 0xbd, 0x8e, 0xd4, 0x30, + 0x14, 0x85, 0xc9, 0xfc, 0x26, 0x37, 0x09, 0x5a, 0xbc, 0xb0, 0x58, 0x43, 0x83, 0x96, 0x66, 0x9b, + 0x4d, 0x81, 0x44, 0x49, 0xc3, 0x22, 0x44, 0x33, 0x12, 0x12, 0x0f, 0x10, 0x5d, 0x1c, 0x27, 0x6b, + 0x4d, 0x62, 0x07, 0xdb, 0x29, 0x96, 0x8a, 0x17, 0xe1, 0x0d, 0x91, 0x78, 0x05, 0x6c, 0x27, 0x99, + 0x1d, 0x8d, 0x28, 0x28, 0xcf, 0xf1, 0xb5, 0xcf, 0x77, 0x8f, 0xe1, 0x8a, 0x29, 0x69, 0xb9, 0xb4, + 0x65, 0x87, 0x52, 0xd4, 0xdc, 0xd8, 0xa2, 0xd7, 0xca, 0xaa, 0xeb, 0x3f, 0x0b, 0xb8, 0xba, 0x1b, + 0x8f, 0xf6, 0xd3, 0xc9, 0x17, 0x7c, 0x68, 0x15, 0x56, 0xe4, 0x1d, 0xc4, 0x1d, 0xf6, 0xbd, 0x90, + 0x8d, 0xa1, 0xd1, 0xeb, 0xe5, 0x4d, 0xfa, 0xf6, 0x4d, 0xf1, 0xef, 0xd1, 0xe2, 0x93, 0x68, 0xf9, + 0x7e, 0x9c, 0xdd, 0xfd, 0x5a, 0x40, 0x7a, 0xa2, 0xc9, 0x05, 0xc4, 0xb5, 0x93, 0x12, 0x3b, 0xee, + 0x9e, 0x89, 0x6e, 0x12, 0x92, 0xc1, 0xca, 0x88, 0x1f, 0x9c, 0x2e, 0x9c, 0x5a, 0x91, 0x1c, 0xd6, + 0x75, 0x8b, 0x2e, 0x63, 0xe9, 0x64, 0x4e, 0x9e, 0x43, 0x66, 0xee, 0xb1, 0x3c, 0x5e, 0x59, 0x39, + 0x37, 0x23, 0x97, 0x90, 0x7a, 0x77, 0x5a, 0x82, 0xae, 0x83, 0xf9, 0x1e, 0x36, 0xec, 0x7e, 0x90, + 0x07, 0x43, 0x37, 0x01, 0xef, 0xf6, 0x3f, 0xf0, 0x8a, 0x3b, 0x7f, 0xe3, 0x23, 0x5a, 0x24, 0x04, + 0xa0, 0x15, 0xf2, 0x60, 0x51, 0x37, 0xdc, 0xd2, 0xad, 0x47, 0xdb, 0x21, 0x24, 0x8f, 0x03, 0x29, + 0x2c, 0x5d, 0x68, 0x80, 0xce, 0xbc, 0x60, 0x9a, 0x05, 0xe6, 0x2d, 0x79, 0x0a, 0x1b, 0x55, 0xd7, + 0xc6, 0x5d, 0x5b, 0x86, 0x1d, 0x1c, 0x1e, 0xfb, 0x56, 0x2a, 0x2d, 0x1a, 0x21, 0xb1, 0x0d, 0xcc, + 0x39, 0x79, 0x01, 0xb9, 0x33, 0x99, 0xea, 0x7a, 0xcd, 0x8d, 0xe1, 0x55, 0xa0, 0xce, 0xaf, 0x7f, + 0x47, 0xf0, 0xf2, 0x8c, 0x73, 0xcf, 0x2d, 0x56, 0x3e, 0xd1, 0x75, 0x55, 0xf1, 0x5e, 0xd9, 0x52, + 0x54, 0x21, 0x36, 0xd4, 0xd1, 0x88, 0xea, 0xf8, 0x6b, 0x53, 0x67, 0xfe, 0x69, 0xcd, 0xd1, 0x0a, + 0x25, 0x4b, 0x2b, 0x5c, 0x4b, 0x63, 0x77, 0xaf, 0xe0, 0x72, 0xee, 0xcd, 0x94, 0x5c, 0x32, 0xfd, + 0xd0, 0x5b, 0x97, 0xeb, 0x71, 0x62, 0x42, 0xe1, 0xc2, 0xe1, 0x54, 0xc2, 0x1c, 0x1e, 0x41, 0xd7, + 0xe1, 0xb5, 0x1d, 0x90, 0xf9, 0xe4, 0x84, 0x76, 0x33, 0x27, 0x0d, 0x52, 0x7c, 0x1f, 0x78, 0x39, + 0x55, 0xbd, 0x3d, 0xee, 0xa6, 0xd9, 0x49, 0x46, 0x1c, 0xec, 0x67, 0x90, 0x78, 0x9b, 0xb5, 0x1c, + 0x35, 0x4d, 0xc2, 0xba, 0xb7, 0x40, 0xcf, 0xb6, 0xfd, 0x2a, 0x1a, 0x89, 0x76, 0xd0, 0xdc, 0x8f, + 0x9b, 0x59, 0x8c, 0x35, 0x7f, 0x58, 0x7f, 0x8e, 0x7e, 0x46, 0x4f, 0xfe, 0x06, 0x00, 0x00, 0xff, + 0xff, 0xc6, 0x87, 0xdb, 0xe6, 0xaf, 0x02, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/base.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/base.pb.go new file mode 100644 index 00000000..ad8394a1 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/base.pb.go @@ -0,0 +1,141 @@ +// Code generated by protoc-gen-go. +// source: steammessages_unified_base.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type EProtoExecutionSite int32 + +const ( + EProtoExecutionSite_k_EProtoExecutionSiteUnknown EProtoExecutionSite = 0 + EProtoExecutionSite_k_EProtoExecutionSiteSteamClient EProtoExecutionSite = 2 +) + +var EProtoExecutionSite_name = map[int32]string{ + 0: "k_EProtoExecutionSiteUnknown", + 2: "k_EProtoExecutionSiteSteamClient", +} +var EProtoExecutionSite_value = map[string]int32{ + "k_EProtoExecutionSiteUnknown": 0, + "k_EProtoExecutionSiteSteamClient": 2, +} + +func (x EProtoExecutionSite) Enum() *EProtoExecutionSite { + p := new(EProtoExecutionSite) + *p = x + return p +} +func (x EProtoExecutionSite) String() string { + return proto.EnumName(EProtoExecutionSite_name, int32(x)) +} +func (x *EProtoExecutionSite) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(EProtoExecutionSite_value, data, "EProtoExecutionSite") + if err != nil { + return err + } + *x = EProtoExecutionSite(value) + return nil +} +func (EProtoExecutionSite) EnumDescriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} } + +type NoResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *NoResponse) Reset() { *m = NoResponse{} } +func (m *NoResponse) String() string { return proto.CompactTextString(m) } +func (*NoResponse) ProtoMessage() {} +func (*NoResponse) Descriptor() ([]byte, []int) { return base_fileDescriptor0, []int{0} } + +var E_Description = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.FieldOptions)(nil), + ExtensionType: (*string)(nil), + Field: 50000, + Name: "description", + Tag: "bytes,50000,opt,name=description", +} + +var E_ServiceDescription = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.ServiceOptions)(nil), + ExtensionType: (*string)(nil), + Field: 50000, + Name: "service_description", + Tag: "bytes,50000,opt,name=service_description", +} + +var E_ServiceExecutionSite = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.ServiceOptions)(nil), + ExtensionType: (*EProtoExecutionSite)(nil), + Field: 50008, + Name: "service_execution_site", + Tag: "varint,50008,opt,name=service_execution_site,enum=EProtoExecutionSite,def=0", +} + +var E_MethodDescription = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.MethodOptions)(nil), + ExtensionType: (*string)(nil), + Field: 50000, + Name: "method_description", + Tag: "bytes,50000,opt,name=method_description", +} + +var E_EnumDescription = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumOptions)(nil), + ExtensionType: (*string)(nil), + Field: 50000, + Name: "enum_description", + Tag: "bytes,50000,opt,name=enum_description", +} + +var E_EnumValueDescription = &proto.ExtensionDesc{ + ExtendedType: (*google_protobuf.EnumValueOptions)(nil), + ExtensionType: (*string)(nil), + Field: 50000, + Name: "enum_value_description", + Tag: "bytes,50000,opt,name=enum_value_description", +} + +func init() { + proto.RegisterType((*NoResponse)(nil), "NoResponse") + proto.RegisterEnum("EProtoExecutionSite", EProtoExecutionSite_name, EProtoExecutionSite_value) + proto.RegisterExtension(E_Description) + proto.RegisterExtension(E_ServiceDescription) + proto.RegisterExtension(E_ServiceExecutionSite) + proto.RegisterExtension(E_MethodDescription) + proto.RegisterExtension(E_EnumDescription) + proto.RegisterExtension(E_EnumValueDescription) +} + +var base_fileDescriptor0 = []byte{ + // 306 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x90, 0x4d, 0x4b, 0xc3, 0x40, + 0x10, 0x86, 0x1b, 0xc5, 0x83, 0xa3, 0x48, 0x48, 0xa5, 0x88, 0x54, 0x8d, 0xe2, 0x41, 0x44, 0xb6, + 0x20, 0x1e, 0x24, 0x88, 0x07, 0x4b, 0xc4, 0x8b, 0x1f, 0x18, 0xf4, 0x26, 0x21, 0x4d, 0xa6, 0x71, + 0x69, 0xb2, 0x1b, 0xb2, 0xbb, 0xd5, 0xa3, 0x27, 0x7f, 0x9f, 0x47, 0x7f, 0x8e, 0xcd, 0x86, 0x80, + 0xf9, 0x40, 0x8f, 0xc9, 0xfb, 0x3e, 0xb3, 0xcf, 0x0c, 0x9c, 0x08, 0x89, 0x41, 0x9a, 0xa2, 0x10, + 0x41, 0x8c, 0xc2, 0x57, 0x8c, 0x4e, 0x29, 0x46, 0xfe, 0x24, 0x10, 0x48, 0x74, 0x14, 0x26, 0x14, + 0x99, 0x24, 0x59, 0xce, 0x25, 0xdf, 0xb6, 0x63, 0xce, 0xe3, 0x04, 0x47, 0xfa, 0x6b, 0xa2, 0xa6, + 0xa3, 0x08, 0x45, 0x98, 0xd3, 0x4c, 0xf2, 0xbc, 0x6c, 0x1c, 0xac, 0x03, 0xdc, 0xf1, 0x47, 0x14, + 0x19, 0x67, 0x02, 0x8f, 0x5f, 0xa0, 0xef, 0x3e, 0x14, 0xff, 0xdd, 0x77, 0x0c, 0x95, 0xa4, 0x9c, + 0x79, 0x54, 0xa2, 0x65, 0xc3, 0x70, 0xe6, 0x77, 0x04, 0x4f, 0x6c, 0xc6, 0xf8, 0x1b, 0x33, 0x7b, + 0xd6, 0x21, 0xd8, 0x9d, 0x0d, 0xaf, 0x50, 0x1a, 0x6b, 0x25, 0x73, 0xc9, 0x39, 0x83, 0xb5, 0x4a, + 0x60, 0x91, 0x5b, 0x3b, 0xa4, 0xd4, 0x23, 0x95, 0x1e, 0xb9, 0xa6, 0x98, 0x44, 0xf7, 0x3a, 0x15, + 0x5b, 0x5f, 0x9f, 0xcb, 0xb6, 0x71, 0xb4, 0xea, 0x5c, 0x42, 0x5f, 0x60, 0x3e, 0xa7, 0x21, 0xfa, + 0xbf, 0xe9, 0xbd, 0x16, 0xed, 0x95, 0xad, 0x26, 0xaf, 0x60, 0x50, 0xf1, 0x58, 0xb9, 0xf9, 0xa2, + 0xd8, 0xeb, 0xdf, 0x11, 0xdf, 0x7a, 0xc4, 0xc6, 0xe9, 0x26, 0xe9, 0xd8, 0xcd, 0xf9, 0xf3, 0x28, + 0xce, 0x05, 0x58, 0x29, 0xca, 0x57, 0x1e, 0xd5, 0xac, 0x77, 0x5b, 0x4f, 0xde, 0xea, 0x52, 0x53, + 0xfa, 0x1c, 0x4c, 0x64, 0x2a, 0xad, 0xb1, 0xc3, 0x16, 0xeb, 0x2e, 0x2a, 0x4d, 0x72, 0x0c, 0x03, + 0x4d, 0xce, 0x83, 0x44, 0xd5, 0x2f, 0xb6, 0xdf, 0xc9, 0x3f, 0x17, 0xbd, 0xc6, 0x90, 0xab, 0x95, + 0x1b, 0xe3, 0xc3, 0xe8, 0xfd, 0x04, 0x00, 0x00, 0xff, 0xff, 0x5c, 0xf6, 0x07, 0xbb, 0x6e, 0x02, + 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/cloud.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/cloud.pb.go new file mode 100644 index 00000000..d42a8cf7 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/cloud.pb.go @@ -0,0 +1,1424 @@ +// Code generated by protoc-gen-go. +// source: steammessages_cloud.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CCloud_GetUploadServerInfo_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_GetUploadServerInfo_Request) Reset() { *m = CCloud_GetUploadServerInfo_Request{} } +func (m *CCloud_GetUploadServerInfo_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_GetUploadServerInfo_Request) ProtoMessage() {} +func (*CCloud_GetUploadServerInfo_Request) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{0} +} + +func (m *CCloud_GetUploadServerInfo_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CCloud_GetUploadServerInfo_Response struct { + ServerUrl *string `protobuf:"bytes,1,opt,name=server_url" json:"server_url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_GetUploadServerInfo_Response) Reset() { *m = CCloud_GetUploadServerInfo_Response{} } +func (m *CCloud_GetUploadServerInfo_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_GetUploadServerInfo_Response) ProtoMessage() {} +func (*CCloud_GetUploadServerInfo_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{1} +} + +func (m *CCloud_GetUploadServerInfo_Response) GetServerUrl() string { + if m != nil && m.ServerUrl != nil { + return *m.ServerUrl + } + return "" +} + +type CCloud_BeginHTTPUpload_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + FileSize *uint32 `protobuf:"varint,2,opt,name=file_size" json:"file_size,omitempty"` + Filename *string `protobuf:"bytes,3,opt,name=filename" json:"filename,omitempty"` + FileSha *string `protobuf:"bytes,4,opt,name=file_sha" json:"file_sha,omitempty"` + IsPublic *bool `protobuf:"varint,5,opt,name=is_public" json:"is_public,omitempty"` + PlatformsToSync []string `protobuf:"bytes,6,rep,name=platforms_to_sync" json:"platforms_to_sync,omitempty"` + RequestHeadersNames []string `protobuf:"bytes,7,rep,name=request_headers_names" json:"request_headers_names,omitempty"` + RequestHeadersValues []string `protobuf:"bytes,8,rep,name=request_headers_values" json:"request_headers_values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_BeginHTTPUpload_Request) Reset() { *m = CCloud_BeginHTTPUpload_Request{} } +func (m *CCloud_BeginHTTPUpload_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_BeginHTTPUpload_Request) ProtoMessage() {} +func (*CCloud_BeginHTTPUpload_Request) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{2} } + +func (m *CCloud_BeginHTTPUpload_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_BeginHTTPUpload_Request) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CCloud_BeginHTTPUpload_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CCloud_BeginHTTPUpload_Request) GetFileSha() string { + if m != nil && m.FileSha != nil { + return *m.FileSha + } + return "" +} + +func (m *CCloud_BeginHTTPUpload_Request) GetIsPublic() bool { + if m != nil && m.IsPublic != nil { + return *m.IsPublic + } + return false +} + +func (m *CCloud_BeginHTTPUpload_Request) GetPlatformsToSync() []string { + if m != nil { + return m.PlatformsToSync + } + return nil +} + +func (m *CCloud_BeginHTTPUpload_Request) GetRequestHeadersNames() []string { + if m != nil { + return m.RequestHeadersNames + } + return nil +} + +func (m *CCloud_BeginHTTPUpload_Request) GetRequestHeadersValues() []string { + if m != nil { + return m.RequestHeadersValues + } + return nil +} + +type CCloud_BeginHTTPUpload_Response struct { + Ugcid *uint64 `protobuf:"fixed64,1,opt,name=ugcid" json:"ugcid,omitempty"` + Timestamp *uint32 `protobuf:"fixed32,2,opt,name=timestamp" json:"timestamp,omitempty"` + UrlHost *string `protobuf:"bytes,3,opt,name=url_host" json:"url_host,omitempty"` + UrlPath *string `protobuf:"bytes,4,opt,name=url_path" json:"url_path,omitempty"` + UseHttps *bool `protobuf:"varint,5,opt,name=use_https" json:"use_https,omitempty"` + RequestHeaders []*CCloud_BeginHTTPUpload_Response_HTTPHeaders `protobuf:"bytes,6,rep,name=request_headers" json:"request_headers,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_BeginHTTPUpload_Response) Reset() { *m = CCloud_BeginHTTPUpload_Response{} } +func (m *CCloud_BeginHTTPUpload_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_BeginHTTPUpload_Response) ProtoMessage() {} +func (*CCloud_BeginHTTPUpload_Response) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{3} } + +func (m *CCloud_BeginHTTPUpload_Response) GetUgcid() uint64 { + if m != nil && m.Ugcid != nil { + return *m.Ugcid + } + return 0 +} + +func (m *CCloud_BeginHTTPUpload_Response) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CCloud_BeginHTTPUpload_Response) GetUrlHost() string { + if m != nil && m.UrlHost != nil { + return *m.UrlHost + } + return "" +} + +func (m *CCloud_BeginHTTPUpload_Response) GetUrlPath() string { + if m != nil && m.UrlPath != nil { + return *m.UrlPath + } + return "" +} + +func (m *CCloud_BeginHTTPUpload_Response) GetUseHttps() bool { + if m != nil && m.UseHttps != nil { + return *m.UseHttps + } + return false +} + +func (m *CCloud_BeginHTTPUpload_Response) GetRequestHeaders() []*CCloud_BeginHTTPUpload_Response_HTTPHeaders { + if m != nil { + return m.RequestHeaders + } + return nil +} + +type CCloud_BeginHTTPUpload_Response_HTTPHeaders struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_BeginHTTPUpload_Response_HTTPHeaders) Reset() { + *m = CCloud_BeginHTTPUpload_Response_HTTPHeaders{} +} +func (m *CCloud_BeginHTTPUpload_Response_HTTPHeaders) String() string { + return proto.CompactTextString(m) +} +func (*CCloud_BeginHTTPUpload_Response_HTTPHeaders) ProtoMessage() {} +func (*CCloud_BeginHTTPUpload_Response_HTTPHeaders) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{3, 0} +} + +func (m *CCloud_BeginHTTPUpload_Response_HTTPHeaders) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CCloud_BeginHTTPUpload_Response_HTTPHeaders) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CCloud_CommitHTTPUpload_Request struct { + TransferSucceeded *bool `protobuf:"varint,1,opt,name=transfer_succeeded" json:"transfer_succeeded,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + FileSha *string `protobuf:"bytes,3,opt,name=file_sha" json:"file_sha,omitempty"` + Filename *string `protobuf:"bytes,4,opt,name=filename" json:"filename,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_CommitHTTPUpload_Request) Reset() { *m = CCloud_CommitHTTPUpload_Request{} } +func (m *CCloud_CommitHTTPUpload_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_CommitHTTPUpload_Request) ProtoMessage() {} +func (*CCloud_CommitHTTPUpload_Request) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{4} } + +func (m *CCloud_CommitHTTPUpload_Request) GetTransferSucceeded() bool { + if m != nil && m.TransferSucceeded != nil { + return *m.TransferSucceeded + } + return false +} + +func (m *CCloud_CommitHTTPUpload_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_CommitHTTPUpload_Request) GetFileSha() string { + if m != nil && m.FileSha != nil { + return *m.FileSha + } + return "" +} + +func (m *CCloud_CommitHTTPUpload_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +type CCloud_CommitHTTPUpload_Response struct { + FileCommitted *bool `protobuf:"varint,1,opt,name=file_committed" json:"file_committed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_CommitHTTPUpload_Response) Reset() { *m = CCloud_CommitHTTPUpload_Response{} } +func (m *CCloud_CommitHTTPUpload_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_CommitHTTPUpload_Response) ProtoMessage() {} +func (*CCloud_CommitHTTPUpload_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{5} +} + +func (m *CCloud_CommitHTTPUpload_Response) GetFileCommitted() bool { + if m != nil && m.FileCommitted != nil { + return *m.FileCommitted + } + return false +} + +type CCloud_GetFileDetails_Request struct { + Ugcid *uint64 `protobuf:"varint,1,opt,name=ugcid" json:"ugcid,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_GetFileDetails_Request) Reset() { *m = CCloud_GetFileDetails_Request{} } +func (m *CCloud_GetFileDetails_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_GetFileDetails_Request) ProtoMessage() {} +func (*CCloud_GetFileDetails_Request) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{6} } + +func (m *CCloud_GetFileDetails_Request) GetUgcid() uint64 { + if m != nil && m.Ugcid != nil { + return *m.Ugcid + } + return 0 +} + +func (m *CCloud_GetFileDetails_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CCloud_UserFile struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Ugcid *uint64 `protobuf:"varint,2,opt,name=ugcid" json:"ugcid,omitempty"` + Filename *string `protobuf:"bytes,3,opt,name=filename" json:"filename,omitempty"` + Timestamp *uint64 `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"` + FileSize *uint32 `protobuf:"varint,5,opt,name=file_size" json:"file_size,omitempty"` + Url *string `protobuf:"bytes,6,opt,name=url" json:"url,omitempty"` + SteamidCreator *uint64 `protobuf:"fixed64,7,opt,name=steamid_creator" json:"steamid_creator,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_UserFile) Reset() { *m = CCloud_UserFile{} } +func (m *CCloud_UserFile) String() string { return proto.CompactTextString(m) } +func (*CCloud_UserFile) ProtoMessage() {} +func (*CCloud_UserFile) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{7} } + +func (m *CCloud_UserFile) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_UserFile) GetUgcid() uint64 { + if m != nil && m.Ugcid != nil { + return *m.Ugcid + } + return 0 +} + +func (m *CCloud_UserFile) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CCloud_UserFile) GetTimestamp() uint64 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CCloud_UserFile) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CCloud_UserFile) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CCloud_UserFile) GetSteamidCreator() uint64 { + if m != nil && m.SteamidCreator != nil { + return *m.SteamidCreator + } + return 0 +} + +type CCloud_GetFileDetails_Response struct { + Details *CCloud_UserFile `protobuf:"bytes,1,opt,name=details" json:"details,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_GetFileDetails_Response) Reset() { *m = CCloud_GetFileDetails_Response{} } +func (m *CCloud_GetFileDetails_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_GetFileDetails_Response) ProtoMessage() {} +func (*CCloud_GetFileDetails_Response) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{8} } + +func (m *CCloud_GetFileDetails_Response) GetDetails() *CCloud_UserFile { + if m != nil { + return m.Details + } + return nil +} + +type CCloud_EnumerateUserFiles_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + ExtendedDetails *bool `protobuf:"varint,2,opt,name=extended_details" json:"extended_details,omitempty"` + Count *uint32 `protobuf:"varint,3,opt,name=count" json:"count,omitempty"` + StartIndex *uint32 `protobuf:"varint,4,opt,name=start_index" json:"start_index,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_EnumerateUserFiles_Request) Reset() { *m = CCloud_EnumerateUserFiles_Request{} } +func (m *CCloud_EnumerateUserFiles_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_EnumerateUserFiles_Request) ProtoMessage() {} +func (*CCloud_EnumerateUserFiles_Request) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{9} +} + +func (m *CCloud_EnumerateUserFiles_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_EnumerateUserFiles_Request) GetExtendedDetails() bool { + if m != nil && m.ExtendedDetails != nil { + return *m.ExtendedDetails + } + return false +} + +func (m *CCloud_EnumerateUserFiles_Request) GetCount() uint32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *CCloud_EnumerateUserFiles_Request) GetStartIndex() uint32 { + if m != nil && m.StartIndex != nil { + return *m.StartIndex + } + return 0 +} + +type CCloud_EnumerateUserFiles_Response struct { + Files []*CCloud_UserFile `protobuf:"bytes,1,rep,name=files" json:"files,omitempty"` + TotalFiles *uint32 `protobuf:"varint,2,opt,name=total_files" json:"total_files,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_EnumerateUserFiles_Response) Reset() { *m = CCloud_EnumerateUserFiles_Response{} } +func (m *CCloud_EnumerateUserFiles_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_EnumerateUserFiles_Response) ProtoMessage() {} +func (*CCloud_EnumerateUserFiles_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{10} +} + +func (m *CCloud_EnumerateUserFiles_Response) GetFiles() []*CCloud_UserFile { + if m != nil { + return m.Files + } + return nil +} + +func (m *CCloud_EnumerateUserFiles_Response) GetTotalFiles() uint32 { + if m != nil && m.TotalFiles != nil { + return *m.TotalFiles + } + return 0 +} + +type CCloud_Delete_Request struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_Delete_Request) Reset() { *m = CCloud_Delete_Request{} } +func (m *CCloud_Delete_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_Delete_Request) ProtoMessage() {} +func (*CCloud_Delete_Request) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{11} } + +func (m *CCloud_Delete_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CCloud_Delete_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CCloud_Delete_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_Delete_Response) Reset() { *m = CCloud_Delete_Response{} } +func (m *CCloud_Delete_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_Delete_Response) ProtoMessage() {} +func (*CCloud_Delete_Response) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{12} } + +type CCloud_GetClientEncryptionKey_Request struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_GetClientEncryptionKey_Request) Reset() { *m = CCloud_GetClientEncryptionKey_Request{} } +func (m *CCloud_GetClientEncryptionKey_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_GetClientEncryptionKey_Request) ProtoMessage() {} +func (*CCloud_GetClientEncryptionKey_Request) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{13} +} + +type CCloud_GetClientEncryptionKey_Response struct { + Key []byte `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Crc *int32 `protobuf:"varint,2,opt,name=crc" json:"crc,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_GetClientEncryptionKey_Response) Reset() { + *m = CCloud_GetClientEncryptionKey_Response{} +} +func (m *CCloud_GetClientEncryptionKey_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_GetClientEncryptionKey_Response) ProtoMessage() {} +func (*CCloud_GetClientEncryptionKey_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{14} +} + +func (m *CCloud_GetClientEncryptionKey_Response) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +func (m *CCloud_GetClientEncryptionKey_Response) GetCrc() int32 { + if m != nil && m.Crc != nil { + return *m.Crc + } + return 0 +} + +type CCloud_CDNReport_Notification struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Url *string `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"` + Success *bool `protobuf:"varint,3,opt,name=success" json:"success,omitempty"` + HttpStatusCode *uint32 `protobuf:"varint,4,opt,name=http_status_code" json:"http_status_code,omitempty"` + ExpectedBytes *uint64 `protobuf:"varint,5,opt,name=expected_bytes" json:"expected_bytes,omitempty"` + ReceivedBytes *uint64 `protobuf:"varint,6,opt,name=received_bytes" json:"received_bytes,omitempty"` + Duration *uint32 `protobuf:"varint,7,opt,name=duration" json:"duration,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_CDNReport_Notification) Reset() { *m = CCloud_CDNReport_Notification{} } +func (m *CCloud_CDNReport_Notification) String() string { return proto.CompactTextString(m) } +func (*CCloud_CDNReport_Notification) ProtoMessage() {} +func (*CCloud_CDNReport_Notification) Descriptor() ([]byte, []int) { return cloud_fileDescriptor0, []int{15} } + +func (m *CCloud_CDNReport_Notification) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CCloud_CDNReport_Notification) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *CCloud_CDNReport_Notification) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +func (m *CCloud_CDNReport_Notification) GetHttpStatusCode() uint32 { + if m != nil && m.HttpStatusCode != nil { + return *m.HttpStatusCode + } + return 0 +} + +func (m *CCloud_CDNReport_Notification) GetExpectedBytes() uint64 { + if m != nil && m.ExpectedBytes != nil { + return *m.ExpectedBytes + } + return 0 +} + +func (m *CCloud_CDNReport_Notification) GetReceivedBytes() uint64 { + if m != nil && m.ReceivedBytes != nil { + return *m.ReceivedBytes + } + return 0 +} + +func (m *CCloud_CDNReport_Notification) GetDuration() uint32 { + if m != nil && m.Duration != nil { + return *m.Duration + } + return 0 +} + +type CCloud_ExternalStorageTransferReport_Notification struct { + Host *string `protobuf:"bytes,1,opt,name=host" json:"host,omitempty"` + Path *string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"` + IsUpload *bool `protobuf:"varint,3,opt,name=is_upload" json:"is_upload,omitempty"` + Success *bool `protobuf:"varint,4,opt,name=success" json:"success,omitempty"` + HttpStatusCode *uint32 `protobuf:"varint,5,opt,name=http_status_code" json:"http_status_code,omitempty"` + BytesExpected *uint64 `protobuf:"varint,6,opt,name=bytes_expected" json:"bytes_expected,omitempty"` + BytesActual *uint64 `protobuf:"varint,7,opt,name=bytes_actual" json:"bytes_actual,omitempty"` + DurationMs *uint32 `protobuf:"varint,8,opt,name=duration_ms" json:"duration_ms,omitempty"` + Cellid *uint32 `protobuf:"varint,9,opt,name=cellid" json:"cellid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) Reset() { + *m = CCloud_ExternalStorageTransferReport_Notification{} +} +func (m *CCloud_ExternalStorageTransferReport_Notification) String() string { + return proto.CompactTextString(m) +} +func (*CCloud_ExternalStorageTransferReport_Notification) ProtoMessage() {} +func (*CCloud_ExternalStorageTransferReport_Notification) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{16} +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetPath() string { + if m != nil && m.Path != nil { + return *m.Path + } + return "" +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetIsUpload() bool { + if m != nil && m.IsUpload != nil { + return *m.IsUpload + } + return false +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetHttpStatusCode() uint32 { + if m != nil && m.HttpStatusCode != nil { + return *m.HttpStatusCode + } + return 0 +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetBytesExpected() uint64 { + if m != nil && m.BytesExpected != nil { + return *m.BytesExpected + } + return 0 +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetBytesActual() uint64 { + if m != nil && m.BytesActual != nil { + return *m.BytesActual + } + return 0 +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetDurationMs() uint32 { + if m != nil && m.DurationMs != nil { + return *m.DurationMs + } + return 0 +} + +func (m *CCloud_ExternalStorageTransferReport_Notification) GetCellid() uint32 { + if m != nil && m.Cellid != nil { + return *m.Cellid + } + return 0 +} + +type CCloud_ClientBeginFileUpload_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + FileSize *uint32 `protobuf:"varint,2,opt,name=file_size" json:"file_size,omitempty"` + RawFileSize *uint32 `protobuf:"varint,3,opt,name=raw_file_size" json:"raw_file_size,omitempty"` + FileSha []byte `protobuf:"bytes,4,opt,name=file_sha" json:"file_sha,omitempty"` + TimeStamp *uint64 `protobuf:"varint,5,opt,name=time_stamp" json:"time_stamp,omitempty"` + Filename *string `protobuf:"bytes,6,opt,name=filename" json:"filename,omitempty"` + PlatformsToSync *uint32 `protobuf:"varint,7,opt,name=platforms_to_sync,def=4294967295" json:"platforms_to_sync,omitempty"` + CellId *uint32 `protobuf:"varint,9,opt,name=cell_id" json:"cell_id,omitempty"` + CanEncrypt *bool `protobuf:"varint,10,opt,name=can_encrypt" json:"can_encrypt,omitempty"` + IsSharedFile *bool `protobuf:"varint,11,opt,name=is_shared_file" json:"is_shared_file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientBeginFileUpload_Request) Reset() { *m = CCloud_ClientBeginFileUpload_Request{} } +func (m *CCloud_ClientBeginFileUpload_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientBeginFileUpload_Request) ProtoMessage() {} +func (*CCloud_ClientBeginFileUpload_Request) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{17} +} + +const Default_CCloud_ClientBeginFileUpload_Request_PlatformsToSync uint32 = 4294967295 + +func (m *CCloud_ClientBeginFileUpload_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetRawFileSize() uint32 { + if m != nil && m.RawFileSize != nil { + return *m.RawFileSize + } + return 0 +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetFileSha() []byte { + if m != nil { + return m.FileSha + } + return nil +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetTimeStamp() uint64 { + if m != nil && m.TimeStamp != nil { + return *m.TimeStamp + } + return 0 +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetPlatformsToSync() uint32 { + if m != nil && m.PlatformsToSync != nil { + return *m.PlatformsToSync + } + return Default_CCloud_ClientBeginFileUpload_Request_PlatformsToSync +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetCellId() uint32 { + if m != nil && m.CellId != nil { + return *m.CellId + } + return 0 +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetCanEncrypt() bool { + if m != nil && m.CanEncrypt != nil { + return *m.CanEncrypt + } + return false +} + +func (m *CCloud_ClientBeginFileUpload_Request) GetIsSharedFile() bool { + if m != nil && m.IsSharedFile != nil { + return *m.IsSharedFile + } + return false +} + +type ClientCloudFileUploadBlockDetails struct { + UrlHost *string `protobuf:"bytes,1,opt,name=url_host" json:"url_host,omitempty"` + UrlPath *string `protobuf:"bytes,2,opt,name=url_path" json:"url_path,omitempty"` + UseHttps *bool `protobuf:"varint,3,opt,name=use_https" json:"use_https,omitempty"` + HttpMethod *int32 `protobuf:"varint,4,opt,name=http_method" json:"http_method,omitempty"` + RequestHeaders []*ClientCloudFileUploadBlockDetails_HTTPHeaders `protobuf:"bytes,5,rep,name=request_headers" json:"request_headers,omitempty"` + BlockOffset *uint64 `protobuf:"varint,6,opt,name=block_offset" json:"block_offset,omitempty"` + BlockLength *uint32 `protobuf:"varint,7,opt,name=block_length" json:"block_length,omitempty"` + ExplicitBodyData []byte `protobuf:"bytes,8,opt,name=explicit_body_data" json:"explicit_body_data,omitempty"` + MayParallelize *bool `protobuf:"varint,9,opt,name=may_parallelize" json:"may_parallelize,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ClientCloudFileUploadBlockDetails) Reset() { *m = ClientCloudFileUploadBlockDetails{} } +func (m *ClientCloudFileUploadBlockDetails) String() string { return proto.CompactTextString(m) } +func (*ClientCloudFileUploadBlockDetails) ProtoMessage() {} +func (*ClientCloudFileUploadBlockDetails) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{18} +} + +func (m *ClientCloudFileUploadBlockDetails) GetUrlHost() string { + if m != nil && m.UrlHost != nil { + return *m.UrlHost + } + return "" +} + +func (m *ClientCloudFileUploadBlockDetails) GetUrlPath() string { + if m != nil && m.UrlPath != nil { + return *m.UrlPath + } + return "" +} + +func (m *ClientCloudFileUploadBlockDetails) GetUseHttps() bool { + if m != nil && m.UseHttps != nil { + return *m.UseHttps + } + return false +} + +func (m *ClientCloudFileUploadBlockDetails) GetHttpMethod() int32 { + if m != nil && m.HttpMethod != nil { + return *m.HttpMethod + } + return 0 +} + +func (m *ClientCloudFileUploadBlockDetails) GetRequestHeaders() []*ClientCloudFileUploadBlockDetails_HTTPHeaders { + if m != nil { + return m.RequestHeaders + } + return nil +} + +func (m *ClientCloudFileUploadBlockDetails) GetBlockOffset() uint64 { + if m != nil && m.BlockOffset != nil { + return *m.BlockOffset + } + return 0 +} + +func (m *ClientCloudFileUploadBlockDetails) GetBlockLength() uint32 { + if m != nil && m.BlockLength != nil { + return *m.BlockLength + } + return 0 +} + +func (m *ClientCloudFileUploadBlockDetails) GetExplicitBodyData() []byte { + if m != nil { + return m.ExplicitBodyData + } + return nil +} + +func (m *ClientCloudFileUploadBlockDetails) GetMayParallelize() bool { + if m != nil && m.MayParallelize != nil { + return *m.MayParallelize + } + return false +} + +type ClientCloudFileUploadBlockDetails_HTTPHeaders struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ClientCloudFileUploadBlockDetails_HTTPHeaders) Reset() { + *m = ClientCloudFileUploadBlockDetails_HTTPHeaders{} +} +func (m *ClientCloudFileUploadBlockDetails_HTTPHeaders) String() string { + return proto.CompactTextString(m) +} +func (*ClientCloudFileUploadBlockDetails_HTTPHeaders) ProtoMessage() {} +func (*ClientCloudFileUploadBlockDetails_HTTPHeaders) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{18, 0} +} + +func (m *ClientCloudFileUploadBlockDetails_HTTPHeaders) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ClientCloudFileUploadBlockDetails_HTTPHeaders) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CCloud_ClientBeginFileUpload_Response struct { + EncryptFile *bool `protobuf:"varint,1,opt,name=encrypt_file" json:"encrypt_file,omitempty"` + BlockRequests []*ClientCloudFileUploadBlockDetails `protobuf:"bytes,2,rep,name=block_requests" json:"block_requests,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientBeginFileUpload_Response) Reset() { *m = CCloud_ClientBeginFileUpload_Response{} } +func (m *CCloud_ClientBeginFileUpload_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientBeginFileUpload_Response) ProtoMessage() {} +func (*CCloud_ClientBeginFileUpload_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{19} +} + +func (m *CCloud_ClientBeginFileUpload_Response) GetEncryptFile() bool { + if m != nil && m.EncryptFile != nil { + return *m.EncryptFile + } + return false +} + +func (m *CCloud_ClientBeginFileUpload_Response) GetBlockRequests() []*ClientCloudFileUploadBlockDetails { + if m != nil { + return m.BlockRequests + } + return nil +} + +type CCloud_ClientCommitFileUpload_Request struct { + TransferSucceeded *bool `protobuf:"varint,1,opt,name=transfer_succeeded" json:"transfer_succeeded,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + FileSha []byte `protobuf:"bytes,3,opt,name=file_sha" json:"file_sha,omitempty"` + Filename *string `protobuf:"bytes,4,opt,name=filename" json:"filename,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientCommitFileUpload_Request) Reset() { *m = CCloud_ClientCommitFileUpload_Request{} } +func (m *CCloud_ClientCommitFileUpload_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientCommitFileUpload_Request) ProtoMessage() {} +func (*CCloud_ClientCommitFileUpload_Request) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{20} +} + +func (m *CCloud_ClientCommitFileUpload_Request) GetTransferSucceeded() bool { + if m != nil && m.TransferSucceeded != nil { + return *m.TransferSucceeded + } + return false +} + +func (m *CCloud_ClientCommitFileUpload_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_ClientCommitFileUpload_Request) GetFileSha() []byte { + if m != nil { + return m.FileSha + } + return nil +} + +func (m *CCloud_ClientCommitFileUpload_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +type CCloud_ClientCommitFileUpload_Response struct { + FileCommitted *bool `protobuf:"varint,1,opt,name=file_committed" json:"file_committed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientCommitFileUpload_Response) Reset() { + *m = CCloud_ClientCommitFileUpload_Response{} +} +func (m *CCloud_ClientCommitFileUpload_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientCommitFileUpload_Response) ProtoMessage() {} +func (*CCloud_ClientCommitFileUpload_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{21} +} + +func (m *CCloud_ClientCommitFileUpload_Response) GetFileCommitted() bool { + if m != nil && m.FileCommitted != nil { + return *m.FileCommitted + } + return false +} + +type CCloud_ClientFileDownload_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Filename *string `protobuf:"bytes,2,opt,name=filename" json:"filename,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientFileDownload_Request) Reset() { *m = CCloud_ClientFileDownload_Request{} } +func (m *CCloud_ClientFileDownload_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientFileDownload_Request) ProtoMessage() {} +func (*CCloud_ClientFileDownload_Request) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{22} +} + +func (m *CCloud_ClientFileDownload_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_ClientFileDownload_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +type CCloud_ClientFileDownload_Response struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + FileSize *uint32 `protobuf:"varint,2,opt,name=file_size" json:"file_size,omitempty"` + RawFileSize *uint32 `protobuf:"varint,3,opt,name=raw_file_size" json:"raw_file_size,omitempty"` + ShaFile []byte `protobuf:"bytes,4,opt,name=sha_file" json:"sha_file,omitempty"` + TimeStamp *uint64 `protobuf:"varint,5,opt,name=time_stamp" json:"time_stamp,omitempty"` + IsExplicitDelete *bool `protobuf:"varint,6,opt,name=is_explicit_delete" json:"is_explicit_delete,omitempty"` + UrlHost *string `protobuf:"bytes,7,opt,name=url_host" json:"url_host,omitempty"` + UrlPath *string `protobuf:"bytes,8,opt,name=url_path" json:"url_path,omitempty"` + UseHttps *bool `protobuf:"varint,9,opt,name=use_https" json:"use_https,omitempty"` + RequestHeaders []*CCloud_ClientFileDownload_Response_HTTPHeaders `protobuf:"bytes,10,rep,name=request_headers" json:"request_headers,omitempty"` + Encrypted *bool `protobuf:"varint,11,opt,name=encrypted" json:"encrypted,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientFileDownload_Response) Reset() { *m = CCloud_ClientFileDownload_Response{} } +func (m *CCloud_ClientFileDownload_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientFileDownload_Response) ProtoMessage() {} +func (*CCloud_ClientFileDownload_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{23} +} + +func (m *CCloud_ClientFileDownload_Response) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_ClientFileDownload_Response) GetFileSize() uint32 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *CCloud_ClientFileDownload_Response) GetRawFileSize() uint32 { + if m != nil && m.RawFileSize != nil { + return *m.RawFileSize + } + return 0 +} + +func (m *CCloud_ClientFileDownload_Response) GetShaFile() []byte { + if m != nil { + return m.ShaFile + } + return nil +} + +func (m *CCloud_ClientFileDownload_Response) GetTimeStamp() uint64 { + if m != nil && m.TimeStamp != nil { + return *m.TimeStamp + } + return 0 +} + +func (m *CCloud_ClientFileDownload_Response) GetIsExplicitDelete() bool { + if m != nil && m.IsExplicitDelete != nil { + return *m.IsExplicitDelete + } + return false +} + +func (m *CCloud_ClientFileDownload_Response) GetUrlHost() string { + if m != nil && m.UrlHost != nil { + return *m.UrlHost + } + return "" +} + +func (m *CCloud_ClientFileDownload_Response) GetUrlPath() string { + if m != nil && m.UrlPath != nil { + return *m.UrlPath + } + return "" +} + +func (m *CCloud_ClientFileDownload_Response) GetUseHttps() bool { + if m != nil && m.UseHttps != nil { + return *m.UseHttps + } + return false +} + +func (m *CCloud_ClientFileDownload_Response) GetRequestHeaders() []*CCloud_ClientFileDownload_Response_HTTPHeaders { + if m != nil { + return m.RequestHeaders + } + return nil +} + +func (m *CCloud_ClientFileDownload_Response) GetEncrypted() bool { + if m != nil && m.Encrypted != nil { + return *m.Encrypted + } + return false +} + +type CCloud_ClientFileDownload_Response_HTTPHeaders struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientFileDownload_Response_HTTPHeaders) Reset() { + *m = CCloud_ClientFileDownload_Response_HTTPHeaders{} +} +func (m *CCloud_ClientFileDownload_Response_HTTPHeaders) String() string { + return proto.CompactTextString(m) +} +func (*CCloud_ClientFileDownload_Response_HTTPHeaders) ProtoMessage() {} +func (*CCloud_ClientFileDownload_Response_HTTPHeaders) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{23, 0} +} + +func (m *CCloud_ClientFileDownload_Response_HTTPHeaders) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CCloud_ClientFileDownload_Response_HTTPHeaders) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CCloud_ClientDeleteFile_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Filename *string `protobuf:"bytes,2,opt,name=filename" json:"filename,omitempty"` + IsExplicitDelete *bool `protobuf:"varint,3,opt,name=is_explicit_delete" json:"is_explicit_delete,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientDeleteFile_Request) Reset() { *m = CCloud_ClientDeleteFile_Request{} } +func (m *CCloud_ClientDeleteFile_Request) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientDeleteFile_Request) ProtoMessage() {} +func (*CCloud_ClientDeleteFile_Request) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{24} +} + +func (m *CCloud_ClientDeleteFile_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CCloud_ClientDeleteFile_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CCloud_ClientDeleteFile_Request) GetIsExplicitDelete() bool { + if m != nil && m.IsExplicitDelete != nil { + return *m.IsExplicitDelete + } + return false +} + +type CCloud_ClientDeleteFile_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCloud_ClientDeleteFile_Response) Reset() { *m = CCloud_ClientDeleteFile_Response{} } +func (m *CCloud_ClientDeleteFile_Response) String() string { return proto.CompactTextString(m) } +func (*CCloud_ClientDeleteFile_Response) ProtoMessage() {} +func (*CCloud_ClientDeleteFile_Response) Descriptor() ([]byte, []int) { + return cloud_fileDescriptor0, []int{25} +} + +func init() { + proto.RegisterType((*CCloud_GetUploadServerInfo_Request)(nil), "CCloud_GetUploadServerInfo_Request") + proto.RegisterType((*CCloud_GetUploadServerInfo_Response)(nil), "CCloud_GetUploadServerInfo_Response") + proto.RegisterType((*CCloud_BeginHTTPUpload_Request)(nil), "CCloud_BeginHTTPUpload_Request") + proto.RegisterType((*CCloud_BeginHTTPUpload_Response)(nil), "CCloud_BeginHTTPUpload_Response") + proto.RegisterType((*CCloud_BeginHTTPUpload_Response_HTTPHeaders)(nil), "CCloud_BeginHTTPUpload_Response.HTTPHeaders") + proto.RegisterType((*CCloud_CommitHTTPUpload_Request)(nil), "CCloud_CommitHTTPUpload_Request") + proto.RegisterType((*CCloud_CommitHTTPUpload_Response)(nil), "CCloud_CommitHTTPUpload_Response") + proto.RegisterType((*CCloud_GetFileDetails_Request)(nil), "CCloud_GetFileDetails_Request") + proto.RegisterType((*CCloud_UserFile)(nil), "CCloud_UserFile") + proto.RegisterType((*CCloud_GetFileDetails_Response)(nil), "CCloud_GetFileDetails_Response") + proto.RegisterType((*CCloud_EnumerateUserFiles_Request)(nil), "CCloud_EnumerateUserFiles_Request") + proto.RegisterType((*CCloud_EnumerateUserFiles_Response)(nil), "CCloud_EnumerateUserFiles_Response") + proto.RegisterType((*CCloud_Delete_Request)(nil), "CCloud_Delete_Request") + proto.RegisterType((*CCloud_Delete_Response)(nil), "CCloud_Delete_Response") + proto.RegisterType((*CCloud_GetClientEncryptionKey_Request)(nil), "CCloud_GetClientEncryptionKey_Request") + proto.RegisterType((*CCloud_GetClientEncryptionKey_Response)(nil), "CCloud_GetClientEncryptionKey_Response") + proto.RegisterType((*CCloud_CDNReport_Notification)(nil), "CCloud_CDNReport_Notification") + proto.RegisterType((*CCloud_ExternalStorageTransferReport_Notification)(nil), "CCloud_ExternalStorageTransferReport_Notification") + proto.RegisterType((*CCloud_ClientBeginFileUpload_Request)(nil), "CCloud_ClientBeginFileUpload_Request") + proto.RegisterType((*ClientCloudFileUploadBlockDetails)(nil), "ClientCloudFileUploadBlockDetails") + proto.RegisterType((*ClientCloudFileUploadBlockDetails_HTTPHeaders)(nil), "ClientCloudFileUploadBlockDetails.HTTPHeaders") + proto.RegisterType((*CCloud_ClientBeginFileUpload_Response)(nil), "CCloud_ClientBeginFileUpload_Response") + proto.RegisterType((*CCloud_ClientCommitFileUpload_Request)(nil), "CCloud_ClientCommitFileUpload_Request") + proto.RegisterType((*CCloud_ClientCommitFileUpload_Response)(nil), "CCloud_ClientCommitFileUpload_Response") + proto.RegisterType((*CCloud_ClientFileDownload_Request)(nil), "CCloud_ClientFileDownload_Request") + proto.RegisterType((*CCloud_ClientFileDownload_Response)(nil), "CCloud_ClientFileDownload_Response") + proto.RegisterType((*CCloud_ClientFileDownload_Response_HTTPHeaders)(nil), "CCloud_ClientFileDownload_Response.HTTPHeaders") + proto.RegisterType((*CCloud_ClientDeleteFile_Request)(nil), "CCloud_ClientDeleteFile_Request") + proto.RegisterType((*CCloud_ClientDeleteFile_Response)(nil), "CCloud_ClientDeleteFile_Response") +} + +var cloud_fileDescriptor0 = []byte{ + // 3368 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x59, 0x4b, 0x6f, 0x1c, 0xc7, + 0xb5, 0xc6, 0x88, 0x1c, 0x8a, 0x2c, 0x8a, 0xa2, 0x54, 0xbe, 0xa2, 0xc7, 0xf4, 0x43, 0xa5, 0x96, + 0x25, 0x4a, 0xf6, 0xa8, 0x24, 0xd1, 0x92, 0x65, 0x59, 0xd7, 0xd7, 0x97, 0x43, 0x52, 0x12, 0x7d, + 0xaf, 0x1e, 0x21, 0x29, 0x3b, 0xb6, 0x93, 0x34, 0x8a, 0x33, 0x35, 0x64, 0x43, 0x3d, 0xdd, 0x93, + 0xee, 0x1e, 0x91, 0xe3, 0xd8, 0x86, 0xe1, 0x2c, 0xe2, 0x45, 0xb2, 0x4b, 0x82, 0xbc, 0x80, 0x6c, + 0xb2, 0x08, 0x02, 0x78, 0x99, 0x4d, 0x90, 0x3f, 0x10, 0x20, 0x9b, 0xfc, 0x83, 0x00, 0x59, 0x65, + 0x91, 0x45, 0xfe, 0x40, 0x90, 0x73, 0x4e, 0x55, 0x3f, 0xe6, 0xc1, 0x97, 0x1f, 0x01, 0x04, 0x81, + 0x53, 0x55, 0xe7, 0xd4, 0xa9, 0xf3, 0xfc, 0xce, 0x69, 0x76, 0x2e, 0x4e, 0xb4, 0x6a, 0xb5, 0x74, + 0x1c, 0xab, 0x4d, 0x1d, 0xbb, 0x75, 0x3f, 0xec, 0x34, 0x24, 0xad, 0xd5, 0x7d, 0x4f, 0x07, 0x89, + 0x6c, 0x47, 0x61, 0x12, 0xce, 0x56, 0x7b, 0x8f, 0x75, 0x02, 0xaf, 0xe9, 0xe9, 0x86, 0xbb, 0xa1, + 0x62, 0x3d, 0x78, 0xda, 0x69, 0x30, 0x67, 0x71, 0x11, 0x39, 0xb9, 0x77, 0x74, 0xf2, 0xa8, 0xed, + 0x87, 0xaa, 0xb1, 0xa6, 0xa3, 0x27, 0x3a, 0x5a, 0x09, 0x9a, 0xa1, 0xbb, 0xaa, 0xbf, 0xdb, 0xd1, + 0x71, 0xc2, 0xff, 0x87, 0x95, 0x55, 0xbb, 0xed, 0x35, 0x2a, 0x25, 0x51, 0xba, 0x30, 0x55, 0xbb, + 0xfc, 0xe9, 0xef, 0x2b, 0x2f, 0x2f, 0xb4, 0xdb, 0x62, 0x65, 0x49, 0x24, 0xa1, 0xd8, 0xde, 0xf2, + 0xea, 0x5b, 0x42, 0x89, 0xa6, 0xe7, 0x6b, 0xb1, 0xed, 0xf9, 0xbe, 0xd8, 0xd0, 0xa2, 0x43, 0xbc, + 0x74, 0x03, 0x0e, 0x48, 0xe7, 0x26, 0x3b, 0xbb, 0xe7, 0x2d, 0x71, 0x3b, 0x0c, 0x62, 0xcd, 0x39, + 0x63, 0x31, 0x2d, 0xbb, 0x9d, 0xc8, 0xa7, 0xbb, 0x26, 0x9c, 0x1f, 0x8f, 0xb1, 0x17, 0x2c, 0x6d, + 0x4d, 0x6f, 0x7a, 0xc1, 0xdd, 0xf5, 0xf5, 0x87, 0x86, 0x43, 0x26, 0xdd, 0x9b, 0xbd, 0xd2, 0x5d, + 0x01, 0xe9, 0xaa, 0x56, 0xba, 0x66, 0x18, 0x59, 0xf1, 0x92, 0x2d, 0x6d, 0x04, 0xf4, 0x62, 0x10, + 0xcf, 0x0b, 0x36, 0x33, 0x09, 0x25, 0x7f, 0x85, 0x4d, 0xe0, 0x96, 0x1b, 0x7b, 0x1f, 0xe8, 0xca, + 0x11, 0x62, 0x22, 0x80, 0xc9, 0x73, 0x0f, 0x22, 0x0f, 0x6e, 0x54, 0xbe, 0x21, 0xc4, 0x5d, 0xe1, + 0x05, 0x62, 0xa3, 0x9b, 0xe8, 0x58, 0xf2, 0x37, 0xd8, 0x38, 0x2e, 0x07, 0xaa, 0xa5, 0x2b, 0x23, + 0x28, 0x6a, 0xed, 0x65, 0xa0, 0x99, 0xbb, 0x0f, 0xbf, 0x45, 0xd8, 0xcc, 0xef, 0x03, 0x05, 0xc5, + 0x49, 0x18, 0x11, 0x29, 0x2e, 0x1a, 0xbb, 0xf1, 0xb7, 0x0d, 0xb9, 0x1b, 0x6f, 0xa9, 0xca, 0x28, + 0x91, 0x2f, 0x01, 0xf9, 0xff, 0xde, 0xd5, 0x3b, 0x70, 0x3c, 0x42, 0xf9, 0x2e, 0x5c, 0xbb, 0x22, + 0x1a, 0x20, 0x40, 0x12, 0x5f, 0x14, 0x91, 0x6e, 0x47, 0x3a, 0x06, 0xb3, 0xe1, 0x06, 0x72, 0x59, + 0xbb, 0xbb, 0x70, 0x15, 0x77, 0xe1, 0xfd, 0xc5, 0xdb, 0x24, 0xff, 0x16, 0x9b, 0xf0, 0x62, 0xb7, + 0xdd, 0xd9, 0xf0, 0xbd, 0x7a, 0xa5, 0x0c, 0x8c, 0xc7, 0x6b, 0x2b, 0xc0, 0x78, 0x79, 0x3d, 0xea, + 0x80, 0x08, 0x05, 0xb9, 0xe2, 0xad, 0xb0, 0xe3, 0x37, 0xd0, 0x54, 0x2d, 0x15, 0x3d, 0x06, 0x43, + 0x19, 0x1a, 0x11, 0x1a, 0x31, 0x1f, 0xdd, 0x5e, 0xab, 0x8a, 0xa6, 0xf2, 0x63, 0x78, 0x0d, 0xfc, + 0x8e, 0xb6, 0x3d, 0xf0, 0x1f, 0xfe, 0x01, 0x3b, 0xd9, 0xf6, 0x55, 0x02, 0x6a, 0x6d, 0xc5, 0x6e, + 0x12, 0xba, 0x71, 0x37, 0xa8, 0x57, 0xc6, 0xc4, 0x08, 0x88, 0xef, 0xc2, 0x2d, 0xef, 0x2f, 0x44, + 0x91, 0xea, 0xa2, 0x40, 0xf6, 0x0d, 0x71, 0x5b, 0xd7, 0xbd, 0x66, 0x17, 0xff, 0x34, 0x66, 0xc8, + 0xa8, 0x49, 0x2f, 0x40, 0x7d, 0x4b, 0x3c, 0x51, 0x3e, 0x88, 0x46, 0xff, 0xc7, 0xaf, 0x0b, 0xe5, + 0xfb, 0x55, 0x70, 0xa2, 0xa0, 0x11, 0x6e, 0xc7, 0x55, 0x11, 0xc6, 0x3b, 0x55, 0xe1, 0x7b, 0x41, + 0x67, 0x47, 0xf2, 0x88, 0x9d, 0x8a, 0x8c, 0xc5, 0xdd, 0x2d, 0x0d, 0x86, 0x8b, 0x62, 0x17, 0x95, + 0x1f, 0x57, 0x8e, 0xd2, 0xfd, 0x6b, 0x70, 0xff, 0x03, 0xd4, 0x7e, 0x4c, 0x56, 0xb7, 0x47, 0x44, + 0x37, 0xec, 0xcc, 0x81, 0x47, 0x6e, 0xab, 0x20, 0xa1, 0x2b, 0x75, 0x82, 0x2f, 0x84, 0xd5, 0xc8, + 0x3a, 0x80, 0xb0, 0x4c, 0xa5, 0xb8, 0x07, 0xa2, 0x83, 0x3a, 0x7c, 0xdd, 0x4c, 0xc4, 0x86, 0xaf, + 0x82, 0xc7, 0x92, 0xff, 0xb4, 0xc4, 0x66, 0xfa, 0x2f, 0x35, 0x92, 0x56, 0xc6, 0xe9, 0xd6, 0x27, + 0x70, 0x6b, 0xf4, 0x36, 0xad, 0x7c, 0xd1, 0x6b, 0xd7, 0x41, 0xdb, 0x41, 0xa7, 0xb5, 0xa1, 0x23, + 0x54, 0x1c, 0x3d, 0x49, 0xb4, 0x3a, 0x60, 0x57, 0x38, 0x00, 0xbe, 0x97, 0xf4, 0x6c, 0x9b, 0xcb, + 0xa5, 0xf3, 0xb3, 0x51, 0x76, 0x7a, 0xd7, 0xb0, 0xb0, 0xe1, 0x74, 0x99, 0x95, 0x3b, 0x9b, 0x75, + 0x1b, 0x17, 0x63, 0xc6, 0xa5, 0x1f, 0xdd, 0x59, 0xc4, 0xb8, 0xb0, 0x2e, 0x93, 0x05, 0xa9, 0xf1, + 0x9d, 0x2b, 0x6c, 0x22, 0xf1, 0xe0, 0xfa, 0x44, 0xb5, 0xda, 0x14, 0x07, 0x47, 0x6b, 0xcf, 0x03, + 0xd1, 0x33, 0x26, 0x56, 0x45, 0xb6, 0x87, 0xe4, 0x86, 0xe2, 0x9b, 0x6c, 0x1c, 0x42, 0xd5, 0xdd, + 0x0a, 0xe3, 0xc4, 0x06, 0xc1, 0x6d, 0x20, 0xa8, 0xdd, 0x85, 0xdf, 0xf4, 0x12, 0x72, 0x05, 0x4b, + 0x9d, 0x26, 0x8a, 0x3e, 0xef, 0xcb, 0x64, 0x78, 0xe2, 0x29, 0x81, 0xcf, 0x10, 0x0f, 0x1f, 0xad, + 0x4b, 0xfe, 0xc0, 0x70, 0x6e, 0xab, 0x64, 0xcb, 0xc6, 0xc7, 0x1b, 0xc0, 0xf9, 0xe6, 0xaa, 0x06, + 0x07, 0xf2, 0x9e, 0x68, 0x81, 0x1b, 0xa8, 0xd2, 0x03, 0x72, 0x97, 0x90, 0xc3, 0x26, 0x3a, 0xb1, + 0x76, 0xb7, 0x92, 0xa4, 0x1d, 0xdb, 0xc0, 0xa0, 0x80, 0x5d, 0x01, 0x55, 0x40, 0x6c, 0x54, 0x05, + 0xec, 0x0a, 0xda, 0xad, 0xe6, 0x1e, 0x9f, 0x2d, 0x4a, 0xfe, 0x3d, 0x36, 0xdd, 0xe7, 0x09, 0xe4, + 0xf8, 0x93, 0xf3, 0x55, 0xb9, 0x8f, 0x21, 0x24, 0xae, 0xdd, 0x35, 0x34, 0xb5, 0x6b, 0x70, 0xe7, + 0x15, 0x74, 0xd3, 0x4b, 0xc6, 0xef, 0xdb, 0xca, 0x8b, 0x28, 0x18, 0x40, 0x58, 0x0c, 0x70, 0x4c, + 0x13, 0xa9, 0x16, 0x32, 0x1f, 0x99, 0x7d, 0x89, 0x4d, 0x16, 0x98, 0xf0, 0x63, 0x6c, 0x94, 0xf2, + 0x0e, 0xa5, 0x48, 0x3e, 0xc5, 0xca, 0xc4, 0x8b, 0x4c, 0x36, 0xe1, 0x7c, 0x9e, 0xbb, 0xc6, 0x62, + 0xd8, 0x6a, 0x79, 0xc9, 0x90, 0x94, 0xf9, 0x9b, 0x12, 0xe3, 0x49, 0xa4, 0x82, 0xb8, 0x09, 0xc9, + 0x36, 0xee, 0xd4, 0xeb, 0x5a, 0x83, 0x92, 0x88, 0xdf, 0x78, 0xed, 0x07, 0x25, 0x90, 0xf1, 0xd3, + 0x52, 0x31, 0x63, 0x64, 0x12, 0x81, 0xa0, 0xb9, 0xe3, 0x88, 0x47, 0xab, 0xff, 0x2f, 0x32, 0x6a, + 0x71, 0x01, 0x7f, 0x42, 0x59, 0x79, 0xe2, 0xe1, 0x2f, 0x78, 0x47, 0x64, 0x15, 0x80, 0x54, 0x24, + 0x90, 0xec, 0x53, 0xd1, 0xc5, 0x34, 0xc5, 0xc0, 0x35, 0x50, 0x3f, 0x94, 0xe7, 0x77, 0x20, 0x51, + 0x86, 0xf5, 0x7a, 0x27, 0x8a, 0xd0, 0x66, 0x3b, 0x69, 0x66, 0x37, 0x49, 0xd9, 0x03, 0xb9, 0xf4, + 0x61, 0x32, 0xbb, 0xb8, 0x87, 0x71, 0xd4, 0x52, 0x89, 0x3d, 0xa6, 0x0c, 0x6d, 0x26, 0xe3, 0x6e, + 0x72, 0x49, 0xfe, 0x93, 0x52, 0x21, 0x3f, 0x1b, 0xcf, 0xfe, 0x14, 0xd5, 0xf2, 0xf1, 0x97, 0x4d, + 0xd0, 0xfd, 0x22, 0x15, 0xcf, 0x1d, 0x40, 0xae, 0x6f, 0x14, 0xaa, 0x8e, 0x09, 0x8b, 0x37, 0x41, + 0xaa, 0x5b, 0xb7, 0xed, 0x9a, 0x50, 0xb1, 0xcd, 0xb9, 0x9e, 0x31, 0x01, 0x5e, 0x31, 0x94, 0x55, + 0xe6, 0x5b, 0xce, 0x47, 0x4c, 0xec, 0xee, 0x2e, 0x36, 0x95, 0xbc, 0xcb, 0x8e, 0x93, 0x36, 0xea, + 0x74, 0x22, 0xc9, 0x5c, 0x65, 0x01, 0x2e, 0x7f, 0x63, 0xa0, 0xb4, 0x6c, 0xa3, 0x14, 0xe8, 0x16, + 0x71, 0xdc, 0xec, 0xf8, 0x7e, 0x57, 0x64, 0x64, 0x83, 0x25, 0xc5, 0xf9, 0x61, 0x89, 0x3d, 0x9f, + 0x83, 0x03, 0x7c, 0xc8, 0x92, 0x4e, 0xc0, 0x13, 0xe2, 0xcc, 0x59, 0x6f, 0x15, 0xf3, 0xd8, 0x68, + 0xad, 0x0a, 0x77, 0x5e, 0xc8, 0x73, 0x18, 0x91, 0x66, 0xa5, 0x76, 0x13, 0x12, 0x6d, 0xc3, 0xd0, + 0xa3, 0x8b, 0x48, 0x2e, 0x7b, 0x5d, 0xe8, 0x34, 0x10, 0x3f, 0x9b, 0x42, 0x97, 0x54, 0xde, 0x0d, + 0xed, 0x87, 0xc1, 0x66, 0x4c, 0x50, 0xe5, 0x47, 0x25, 0x36, 0x6d, 0xc5, 0x79, 0x04, 0xb9, 0x05, + 0xe5, 0xc1, 0x00, 0x2b, 0x00, 0x0c, 0xfc, 0x69, 0xe4, 0x41, 0x96, 0xa3, 0xfc, 0x44, 0x3f, 0x10, + 0xe0, 0x27, 0x8b, 0x79, 0x74, 0x94, 0x0e, 0x9d, 0x2c, 0x42, 0x8c, 0x32, 0xb1, 0x99, 0x64, 0x23, + 0x08, 0x73, 0xc6, 0x88, 0xe4, 0x69, 0x36, 0x4d, 0xe0, 0xcc, 0x6b, 0xb8, 0xf5, 0x48, 0x2b, 0x00, + 0x0c, 0x50, 0xd6, 0x20, 0x6b, 0x3b, 0x8b, 0x19, 0xfc, 0x19, 0xd0, 0x8e, 0xb5, 0xcd, 0x19, 0x76, + 0xd4, 0xbe, 0x98, 0xe4, 0x9b, 0x9c, 0x3f, 0x21, 0xfb, 0x1e, 0xe0, 0xfc, 0x7d, 0x84, 0x9d, 0xb1, + 0x6b, 0xcb, 0x50, 0x4b, 0x74, 0xa4, 0x12, 0x9d, 0x6e, 0xe6, 0x7a, 0xbe, 0xd6, 0x8b, 0xa3, 0xce, + 0x81, 0xaa, 0xce, 0xe4, 0x28, 0x4f, 0xa7, 0x84, 0x99, 0xde, 0x62, 0x30, 0x81, 0xe4, 0xbf, 0x2c, + 0xb1, 0x13, 0x7a, 0x27, 0xd1, 0x01, 0x38, 0xae, 0x9b, 0x0a, 0x72, 0x84, 0xbc, 0xe3, 0x13, 0x8c, + 0x98, 0x0f, 0x2f, 0x3c, 0x68, 0x27, 0x5e, 0x08, 0x30, 0xea, 0xa2, 0x80, 0x27, 0x88, 0xf4, 0x6c, + 0x66, 0xa6, 0x0d, 0x55, 0x7f, 0x9c, 0xa2, 0x0e, 0xc3, 0xb6, 0x19, 0x76, 0x02, 0x08, 0xde, 0x25, + 0xdd, 0x54, 0x1d, 0x3f, 0xa1, 0xec, 0x18, 0x06, 0xe0, 0x46, 0x91, 0x4e, 0x3a, 0x51, 0x80, 0xf1, + 0x91, 0xc6, 0x72, 0x43, 0xa8, 0x00, 0xd2, 0x10, 0x16, 0xb5, 0x46, 0x31, 0xcc, 0x52, 0x1e, 0xfc, + 0x43, 0x56, 0xae, 0xc3, 0x5f, 0xa6, 0x3a, 0x4d, 0xd5, 0x5a, 0x20, 0x90, 0x57, 0x10, 0xe8, 0x9e, + 0xda, 0xf1, 0x5a, 0x9d, 0x56, 0xa1, 0xc0, 0x42, 0x14, 0xa7, 0x77, 0x9a, 0xeb, 0x8c, 0x68, 0x90, + 0x5b, 0xea, 0x00, 0x4d, 0x7a, 0x85, 0x52, 0x10, 0xc7, 0x86, 0x1e, 0x08, 0xaf, 0x5f, 0xb9, 0x62, + 0xaf, 0x4e, 0xc5, 0x44, 0xc8, 0x32, 0x09, 0x4e, 0x10, 0x25, 0x2e, 0xe0, 0x19, 0xbd, 0x43, 0xae, + 0x30, 0x55, 0xfb, 0x36, 0xc8, 0xf0, 0x6e, 0x41, 0x86, 0x35, 0x3c, 0x81, 0x69, 0x83, 0x0e, 0x99, + 0x52, 0x00, 0xa1, 0x9a, 0x29, 0x1c, 0x8e, 0x09, 0x95, 0xf4, 0xde, 0x8c, 0xef, 0xa4, 0x53, 0x01, + 0x12, 0xda, 0x87, 0xfb, 0x1e, 0x86, 0xf3, 0x7b, 0x19, 0xa2, 0x1f, 0x6a, 0x6a, 0xeb, 0x34, 0xa7, + 0x59, 0x99, 0x84, 0x05, 0x5b, 0x8f, 0x0c, 0x73, 0x19, 0xfe, 0x14, 0x9b, 0x4c, 0xc2, 0x44, 0xf9, + 0xae, 0x39, 0x46, 0xd1, 0xe3, 0xbc, 0xcb, 0x4e, 0xd9, 0x73, 0x4b, 0xda, 0xd7, 0x89, 0xce, 0x5c, + 0xa7, 0x18, 0x03, 0xa6, 0x28, 0x1d, 0x36, 0xee, 0x2a, 0x6c, 0xa6, 0x9f, 0xb5, 0x11, 0xd5, 0x99, + 0x63, 0xe7, 0xf2, 0x08, 0x58, 0xa4, 0xe6, 0x65, 0x39, 0xa8, 0x47, 0x5d, 0x52, 0xe0, 0xff, 0xe9, + 0x6e, 0x2a, 0x84, 0x13, 0xb0, 0xf3, 0xfb, 0x1d, 0xb4, 0xaf, 0x9f, 0x63, 0x23, 0x8f, 0x75, 0x97, + 0x24, 0x3d, 0x56, 0x9b, 0x05, 0xd1, 0x66, 0x16, 0x96, 0xd7, 0x2e, 0xcd, 0x5f, 0x7f, 0x15, 0x94, + 0x9e, 0x12, 0x08, 0x38, 0xc1, 0x9f, 0x65, 0x23, 0xf5, 0xa8, 0x4e, 0x6f, 0x28, 0xd7, 0x8e, 0xc3, + 0x41, 0xb6, 0xb8, 0xba, 0x88, 0xfa, 0x86, 0x4d, 0xe7, 0x77, 0x79, 0xe6, 0x5a, 0x5c, 0xba, 0xbf, + 0xaa, 0xdb, 0x21, 0x58, 0xfa, 0x7e, 0x98, 0x40, 0xf2, 0xad, 0x93, 0xd9, 0xf8, 0x34, 0x3b, 0x6a, + 0xa3, 0xda, 0x60, 0xb0, 0x34, 0xe6, 0xa9, 0x50, 0xd3, 0xae, 0xc9, 0x92, 0xe4, 0x9d, 0xe3, 0xbc, + 0xc2, 0x4e, 0x20, 0xd6, 0x70, 0xc1, 0x67, 0x92, 0x0e, 0x74, 0x78, 0x61, 0xc3, 0x24, 0xf9, 0x29, + 0x3e, 0xc3, 0x8e, 0xeb, 0x1d, 0xc8, 0xeb, 0x09, 0x76, 0x72, 0xd8, 0x7f, 0x50, 0x0e, 0x19, 0xc5, + 0xf5, 0x48, 0xd7, 0x35, 0x00, 0xa2, 0x74, 0x7d, 0x2c, 0xcd, 0x49, 0x8d, 0x8e, 0xf1, 0x1d, 0xca, + 0x23, 0x53, 0xce, 0x5f, 0x4b, 0xec, 0x6a, 0xea, 0x17, 0x10, 0x81, 0x11, 0xb8, 0xde, 0x1a, 0x64, + 0x19, 0xe8, 0x11, 0xd7, 0x2d, 0x0e, 0x18, 0xf6, 0x00, 0x00, 0x1a, 0x84, 0xed, 0x8c, 0x4d, 0xe1, + 0x17, 0xe1, 0xb1, 0x23, 0x69, 0x96, 0x83, 0x4e, 0xc3, 0xd4, 0x5a, 0xfb, 0x80, 0xc2, 0x8b, 0x46, + 0x77, 0x7d, 0x51, 0x39, 0x7d, 0x11, 0x09, 0xec, 0xa6, 0xef, 0xb2, 0x92, 0xff, 0x17, 0x3b, 0x66, + 0xd6, 0x55, 0x3d, 0x01, 0xf8, 0x4b, 0xd2, 0x8f, 0xa2, 0x37, 0xa6, 0xef, 0x71, 0x5b, 0x88, 0xbd, + 0x91, 0xc5, 0x71, 0x36, 0x56, 0xd7, 0xbe, 0x0f, 0xca, 0x9d, 0xa0, 0x27, 0xfe, 0xb1, 0xcc, 0x5e, + 0x4c, 0xed, 0x41, 0xd6, 0xa7, 0x92, 0x87, 0xde, 0xfc, 0x55, 0x37, 0x8c, 0x4b, 0x83, 0x0d, 0xe3, + 0x55, 0x60, 0x72, 0x29, 0xef, 0x13, 0xa1, 0x02, 0x12, 0xbe, 0x32, 0x65, 0x8f, 0xb2, 0x14, 0x75, + 0x81, 0x54, 0x94, 0x4d, 0x41, 0xe6, 0xf7, 0xd9, 0x54, 0xa4, 0xb6, 0xdd, 0x9c, 0x93, 0xc9, 0x51, + 0x37, 0x80, 0xd3, 0x2b, 0x39, 0xa7, 0x0d, 0xdd, 0xc4, 0xee, 0x51, 0x05, 0x54, 0x46, 0x11, 0x65, + 0xc4, 0x94, 0x11, 0x82, 0xc6, 0x65, 0x90, 0x35, 0xf7, 0x57, 0xc9, 0x2f, 0xf4, 0xb5, 0x94, 0xc7, + 0x6a, 0x33, 0xc0, 0x8a, 0x03, 0xc2, 0xb8, 0x74, 0x95, 0x52, 0x9b, 0xda, 0xb6, 0xb0, 0xfd, 0x25, + 0xc6, 0xb0, 0x40, 0xb9, 0xa6, 0x42, 0x91, 0x2b, 0x99, 0xb3, 0xeb, 0x83, 0x10, 0xbf, 0xd8, 0xe7, + 0x8e, 0x1d, 0xbe, 0xcf, 0x3d, 0x37, 0xac, 0x63, 0x24, 0x97, 0x7c, 0x9d, 0x5d, 0x9b, 0xbf, 0x79, + 0xed, 0xe6, 0xab, 0x37, 0xe6, 0x6f, 0x5e, 0xe7, 0xb7, 0xd9, 0x51, 0xb4, 0xa5, 0x9b, 0x1a, 0xb3, + 0x76, 0x1d, 0x2e, 0xb9, 0x6a, 0xcc, 0x38, 0x07, 0xb9, 0x17, 0xf6, 0xd0, 0x3c, 0x31, 0xc0, 0x7c, + 0x60, 0xad, 0x02, 0xd1, 0xf6, 0xa0, 0x6a, 0xc4, 0xc6, 0x83, 0x85, 0x1f, 0x1a, 0x7f, 0x45, 0x7c, + 0x34, 0x09, 0xbb, 0xae, 0x55, 0x4b, 0x85, 0x51, 0x1d, 0xfa, 0x6f, 0xe0, 0xf5, 0x9a, 0x97, 0xe2, + 0x7c, 0x33, 0xff, 0x20, 0x26, 0xf6, 0x58, 0x31, 0x23, 0x91, 0xb2, 0x8d, 0xa5, 0x29, 0x27, 0x27, + 0xbc, 0xc9, 0x8e, 0x83, 0x9f, 0x83, 0x52, 0xc1, 0x7a, 0x64, 0xac, 0xca, 0x24, 0x71, 0xbd, 0x0f, + 0x5c, 0xdf, 0xca, 0xb8, 0x52, 0x89, 0x80, 0x7f, 0x9b, 0x21, 0x21, 0x40, 0xc2, 0xf3, 0x58, 0x97, + 0xc0, 0x46, 0x4a, 0xc4, 0x50, 0xd3, 0x75, 0x00, 0x5d, 0x49, 0x82, 0xbf, 0xe3, 0xb0, 0x65, 0x11, + 0x90, 0x30, 0x5c, 0xe9, 0x6e, 0xe7, 0x9f, 0x63, 0x50, 0xa4, 0x49, 0x36, 0xf2, 0x8f, 0xdc, 0x6f, + 0x6b, 0xf0, 0xbc, 0xc7, 0xb6, 0xec, 0xf7, 0x74, 0x5c, 0xa5, 0xaf, 0xad, 0xe3, 0x3a, 0xf2, 0x95, + 0x77, 0x5c, 0x23, 0x87, 0xef, 0xb8, 0x6e, 0xb1, 0x49, 0x4a, 0x1e, 0x2d, 0x9d, 0x6c, 0x85, 0x0d, + 0x72, 0xe9, 0x72, 0xed, 0x3c, 0x70, 0x70, 0x96, 0x51, 0xea, 0x7b, 0xb4, 0x8c, 0x72, 0x20, 0x09, + 0x06, 0x2e, 0xd9, 0x60, 0x03, 0xb5, 0x25, 0xf9, 0x47, 0x83, 0xed, 0x5a, 0x99, 0x4a, 0x9d, 0x94, + 0xfb, 0x2a, 0xf9, 0xcb, 0x37, 0x6c, 0xfc, 0x35, 0x48, 0x63, 0xc8, 0xd1, 0x0d, 0x9b, 0x4d, 0x68, + 0xfe, 0x4d, 0x72, 0xab, 0x39, 0xc0, 0xeb, 0x05, 0xb3, 0x92, 0x06, 0x98, 0x91, 0x97, 0x5e, 0x41, + 0x72, 0xf0, 0x56, 0x4a, 0x09, 0x31, 0xb7, 0x09, 0xa6, 0xa0, 0x58, 0xa9, 0xbd, 0x03, 0x94, 0x6b, + 0x66, 0x65, 0x37, 0x4a, 0x71, 0x09, 0x41, 0xf8, 0x07, 0x3a, 0x0a, 0xab, 0x22, 0x08, 0x41, 0xce, + 0xa8, 0xa7, 0xf3, 0x40, 0xe7, 0xcc, 0xd7, 0x52, 0x45, 0x71, 0x97, 0x71, 0xc8, 0xc0, 0xbe, 0x57, + 0xf7, 0x12, 0x77, 0x23, 0x6c, 0x74, 0xdd, 0x86, 0x4a, 0x14, 0x25, 0xd8, 0x63, 0xb5, 0x45, 0xb8, + 0xf4, 0xcd, 0x74, 0x57, 0xe0, 0xae, 0xc0, 0x5d, 0xab, 0xf2, 0x2a, 0xbc, 0x1c, 0xab, 0x5b, 0x23, + 0x13, 0x08, 0x37, 0xab, 0x7d, 0x96, 0xe0, 0x21, 0x9b, 0x6e, 0xa9, 0x2e, 0xb8, 0x55, 0x04, 0xf8, + 0x49, 0xfb, 0x98, 0xe7, 0x26, 0xc8, 0x17, 0xde, 0x06, 0xee, 0xab, 0xbd, 0xf1, 0x63, 0xd5, 0x07, + 0xb0, 0x8a, 0x26, 0x31, 0x8d, 0x30, 0xa0, 0x74, 0x92, 0xd2, 0x8a, 0x6d, 0x0f, 0x9f, 0x6f, 0x22, + 0xc7, 0x6b, 0x79, 0xbe, 0x8a, 0xfc, 0xee, 0x25, 0x3b, 0xbe, 0xb2, 0xb4, 0xf1, 0xa1, 0x7a, 0xe5, + 0x7f, 0x94, 0x32, 0x70, 0xb1, 0x5b, 0xc9, 0xb0, 0x90, 0xe1, 0x7d, 0x76, 0xcc, 0x66, 0x0b, 0x93, + 0x03, 0x4c, 0xff, 0xb3, 0x0c, 0x6f, 0x58, 0x58, 0xc9, 0xdf, 0x30, 0x30, 0x5b, 0xb3, 0x34, 0x20, + 0xdf, 0x46, 0xd7, 0xa6, 0x45, 0xca, 0x3e, 0x3d, 0x89, 0x86, 0x6f, 0x42, 0x31, 0x24, 0x9b, 0xa7, + 0x8f, 0x00, 0xf1, 0xd0, 0x57, 0x9d, 0xfd, 0x7d, 0xd5, 0x84, 0x14, 0x39, 0x60, 0x4a, 0x8c, 0xf6, + 0x69, 0xa9, 0xc7, 0x94, 0x92, 0xdb, 0x3a, 0xc2, 0xd4, 0x6b, 0x2f, 0x72, 0xfe, 0x34, 0xd2, 0xf7, + 0x5e, 0xd3, 0xf2, 0x0d, 0xa9, 0x91, 0x6a, 0x8f, 0x01, 0x01, 0xbd, 0x3a, 0xed, 0xfa, 0x14, 0xce, + 0x7b, 0xc9, 0x13, 0xcd, 0x1d, 0x71, 0x3e, 0x11, 0x28, 0x76, 0xf7, 0x41, 0xd7, 0x3a, 0x63, 0x8b, + 0xfa, 0xfc, 0xff, 0x7c, 0x77, 0x9f, 0xbf, 0x51, 0xf2, 0x76, 0x5f, 0x73, 0x7f, 0xac, 0xf6, 0x1d, + 0xb8, 0xfc, 0xbd, 0x21, 0x3d, 0x7b, 0x56, 0x33, 0xbf, 0x40, 0xdf, 0x5e, 0xbc, 0xf1, 0x4b, 0xf6, + 0xed, 0x39, 0xab, 0xbc, 0x6f, 0xff, 0x7e, 0x29, 0xc3, 0xbb, 0xbb, 0xda, 0xf2, 0xeb, 0x6f, 0xdf, + 0x3f, 0x29, 0x65, 0xad, 0xa5, 0x91, 0x82, 0x7a, 0xd4, 0x70, 0x3b, 0xe8, 0xf1, 0x26, 0xd9, 0x8b, + 0xb8, 0x86, 0x76, 0x03, 0x79, 0x7e, 0x92, 0xfc, 0xe5, 0x82, 0xba, 0x4c, 0x2d, 0x7a, 0x06, 0x48, + 0x4e, 0x65, 0xea, 0x2a, 0x4e, 0x54, 0x9c, 0x7f, 0x95, 0xb3, 0x96, 0x67, 0xa8, 0x08, 0x56, 0x09, + 0xf3, 0xbd, 0x32, 0x9c, 0x05, 0x86, 0xa7, 0x41, 0x06, 0xdf, 0x62, 0xdd, 0x61, 0x6d, 0x09, 0xbf, + 0x33, 0x08, 0xf4, 0xa8, 0x1e, 0x1c, 0x10, 0xe8, 0x65, 0x56, 0x04, 0x46, 0x43, 0xb1, 0x1e, 0x41, + 0xcf, 0x9c, 0xd9, 0xf6, 0x96, 0x0e, 0xa0, 0x2f, 0x4e, 0x71, 0x9e, 0xe1, 0x87, 0x30, 0x0f, 0xd6, + 0x4c, 0x1a, 0x81, 0x6e, 0x7f, 0x1c, 0xbc, 0xd6, 0xe4, 0x20, 0x03, 0xf2, 0xa6, 0x81, 0xc7, 0x24, + 0xb8, 0x63, 0x9a, 0x86, 0xf9, 0xc5, 0x21, 0xe8, 0xee, 0x14, 0x1c, 0x3a, 0x39, 0x80, 0xee, 0xf8, + 0x5b, 0x8c, 0x7b, 0x04, 0xc1, 0x4d, 0x01, 0x68, 0x50, 0xeb, 0x45, 0xc5, 0x6a, 0xbc, 0x26, 0x81, + 0xe4, 0xa5, 0xdc, 0x39, 0x0c, 0xbc, 0x41, 0xd0, 0x64, 0x4f, 0x83, 0x63, 0x98, 0xf3, 0x06, 0xbf, + 0xf0, 0xcb, 0x05, 0x64, 0x72, 0x94, 0x6c, 0x46, 0xc3, 0x63, 0x42, 0x26, 0x10, 0x18, 0x77, 0x96, + 0xd7, 0x73, 0x15, 0x37, 0xa3, 0xb0, 0xd5, 0x03, 0x38, 0xc6, 0x73, 0xc0, 0xf1, 0xd0, 0xe2, 0x8c, + 0x64, 0x4b, 0x25, 0x62, 0xcb, 0x52, 0xdb, 0x7a, 0x53, 0xf7, 0x3b, 0x04, 0xcb, 0x68, 0xd2, 0x08, + 0x55, 0x01, 0xa0, 0x01, 0x4e, 0xdb, 0x4d, 0x82, 0xe1, 0x37, 0x8a, 0x80, 0xc3, 0x14, 0x99, 0x17, + 0x81, 0xa3, 0x58, 0x41, 0x48, 0x94, 0x18, 0xbc, 0x81, 0x99, 0x72, 0xad, 0x2a, 0xb4, 0x6f, 0xa1, + 0x06, 0xfe, 0xe6, 0x1f, 0x0f, 0x82, 0x05, 0x46, 0x09, 0xf8, 0xb2, 0xdc, 0xdf, 0xb1, 0xbe, 0x18, + 0x5a, 0x40, 0x75, 0x64, 0x68, 0x01, 0x5a, 0xa9, 0xac, 0x50, 0x18, 0x74, 0x79, 0xa8, 0x2a, 0xf6, + 0xb7, 0x52, 0x3e, 0xf1, 0x25, 0x39, 0x4d, 0x0b, 0x8d, 0xd2, 0x1e, 0xe4, 0x13, 0xde, 0x5e, 0xc9, + 0xd6, 0x5a, 0x58, 0x42, 0xcb, 0xdc, 0x1f, 0x91, 0xe4, 0x52, 0xc5, 0x88, 0x34, 0xfd, 0xc2, 0x3b, + 0x43, 0x5d, 0xca, 0xc0, 0xbf, 0x5b, 0x40, 0x72, 0x63, 0xa5, 0x1f, 0x32, 0x2b, 0x31, 0x67, 0x4e, + 0xcd, 0xdd, 0x42, 0x4b, 0x52, 0x8a, 0x01, 0x63, 0x27, 0x76, 0x0f, 0xc4, 0xdb, 0xd4, 0xc9, 0x9c, + 0xe3, 0xe4, 0x73, 0xca, 0xc1, 0x47, 0x1a, 0x53, 0xcc, 0x7f, 0x76, 0x82, 0x95, 0x4d, 0xc0, 0xfd, + 0xaa, 0xc4, 0x9e, 0x1a, 0xf2, 0xb1, 0x91, 0x9f, 0x95, 0xfb, 0x7f, 0xef, 0x9c, 0x7d, 0x51, 0x1e, + 0xe0, 0x73, 0xa5, 0xf3, 0x3a, 0xbc, 0xe6, 0xd5, 0x55, 0x1a, 0xf6, 0xc4, 0xe6, 0x9b, 0x19, 0x78, + 0xa5, 0xcd, 0x4c, 0x50, 0x12, 0xa0, 0xf4, 0x9a, 0x26, 0x28, 0x45, 0xcc, 0x4d, 0xea, 0x05, 0xc0, + 0xe9, 0x22, 0xc9, 0x7f, 0x7b, 0x84, 0x4d, 0xf7, 0x4d, 0x64, 0xf9, 0x69, 0xb9, 0xf7, 0x87, 0xce, + 0x59, 0xb1, 0xdf, 0x97, 0x06, 0xe7, 0x2f, 0x38, 0x71, 0xfb, 0x73, 0x89, 0xf6, 0xe3, 0x54, 0x10, + 0x4c, 0xe4, 0x28, 0x57, 0xde, 0xd5, 0xa8, 0xac, 0x65, 0x5b, 0xc3, 0xf1, 0x04, 0xcd, 0xe4, 0x70, + 0x22, 0x90, 0x35, 0x54, 0x28, 0xb1, 0x07, 0x74, 0x52, 0xdc, 0x3e, 0x40, 0xef, 0x90, 0x4e, 0xa4, + 0xb2, 0xf9, 0x1c, 0x28, 0xa2, 0x2a, 0x54, 0x13, 0x98, 0x16, 0x1c, 0xcb, 0xa2, 0x54, 0xfa, 0xb4, + 0xb5, 0x81, 0x7e, 0x06, 0x17, 0x42, 0xd2, 0x23, 0x64, 0xa4, 0x68, 0xba, 0x46, 0xf5, 0xb3, 0x6f, + 0x06, 0x2d, 0xf9, 0xe7, 0x25, 0x76, 0xa2, 0x7f, 0x95, 0x67, 0xaa, 0xd8, 0xed, 0x13, 0xc7, 0xec, + 0x19, 0xb9, 0xdf, 0x54, 0xdb, 0x59, 0x07, 0x65, 0x3d, 0x34, 0xdb, 0x71, 0xaa, 0x13, 0x2b, 0xa5, + 0x17, 0x78, 0x89, 0xa7, 0x2c, 0x6e, 0xeb, 0x1f, 0x9d, 0x63, 0x92, 0x4f, 0xc1, 0x51, 0x34, 0xd0, + 0x47, 0x6d, 0xb3, 0xe3, 0xbd, 0xa3, 0x5a, 0xfe, 0x82, 0xdc, 0x73, 0xc0, 0x3d, 0x7b, 0x5a, 0xee, + 0x3d, 0xe2, 0x75, 0x28, 0x8b, 0xa5, 0x9e, 0x96, 0xce, 0x4d, 0x71, 0x08, 0x50, 0x98, 0x7e, 0x4b, + 0xfe, 0x87, 0x12, 0xe3, 0x83, 0x33, 0x3f, 0xee, 0xc8, 0x7d, 0x47, 0xbf, 0xb3, 0x67, 0xe5, 0xfe, + 0x33, 0x43, 0xe7, 0x7d, 0x90, 0xe2, 0x9d, 0xec, 0x40, 0x5c, 0xb8, 0x3b, 0x2e, 0xf8, 0x36, 0x7a, + 0x9a, 0x12, 0x9b, 0xd0, 0x31, 0x06, 0x16, 0x91, 0xc9, 0x4c, 0xf4, 0x4e, 0x1b, 0x4d, 0x9c, 0x4f, + 0x4a, 0x21, 0xc1, 0x2b, 0xfa, 0xac, 0x28, 0x79, 0x83, 0x8d, 0x99, 0x80, 0xe6, 0x33, 0x72, 0xe8, + 0x8c, 0x71, 0xf6, 0x69, 0xb9, 0xcb, 0x80, 0xf0, 0x22, 0xc8, 0x75, 0xce, 0x2c, 0x66, 0x66, 0xc4, + 0x02, 0x63, 0xbc, 0x0e, 0x44, 0xc2, 0x01, 0x82, 0x99, 0x46, 0xfc, 0xbc, 0xc4, 0x66, 0x86, 0x0f, + 0x07, 0xf9, 0x79, 0x79, 0xa0, 0x29, 0xe3, 0xec, 0x9c, 0x3c, 0xd8, 0x90, 0xd1, 0xa1, 0xfa, 0x09, + 0x87, 0xe2, 0xa2, 0x1c, 0x85, 0xaf, 0x15, 0xbd, 0xa3, 0x46, 0xc9, 0xeb, 0x6c, 0x22, 0x1b, 0x23, + 0xe6, 0x2e, 0x33, 0x7c, 0xb2, 0x38, 0x3b, 0x29, 0xef, 0x87, 0xbd, 0x0a, 0x30, 0xa7, 0x62, 0x1b, + 0x88, 0x38, 0xc4, 0x36, 0x96, 0x00, 0x06, 0x99, 0xb3, 0x4a, 0xfe, 0xeb, 0x12, 0x7b, 0x7e, 0xcf, + 0xf9, 0x1f, 0x9f, 0x97, 0x87, 0x1e, 0x13, 0xf6, 0x4a, 0x63, 0xa7, 0x06, 0x43, 0xa5, 0x09, 0xf2, + 0x54, 0x63, 0x34, 0x91, 0x26, 0x9c, 0x5c, 0xc2, 0xcf, 0x4a, 0xec, 0xd4, 0xd0, 0x5e, 0x8c, 0x9f, + 0x93, 0x07, 0x99, 0xee, 0xcd, 0x9e, 0x97, 0x07, 0xea, 0xe8, 0x1c, 0xfa, 0x1e, 0xbe, 0x62, 0xe3, + 0x1c, 0x45, 0xb3, 0xa1, 0x9f, 0x81, 0x78, 0xfe, 0x0b, 0xf0, 0x96, 0xe1, 0xd0, 0x9a, 0xf7, 0x5d, + 0xb2, 0x5b, 0x1b, 0x95, 0x7b, 0xcb, 0x3e, 0x10, 0xdd, 0xa1, 0x82, 0x6c, 0xb6, 0xf3, 0x32, 0x6c, + 0x25, 0x82, 0xd8, 0xf2, 0x82, 0x06, 0x2a, 0x5b, 0xa7, 0x1f, 0x49, 0xf1, 0xcb, 0x06, 0x1f, 0x04, + 0x25, 0x79, 0xb0, 0xef, 0x0e, 0xc6, 0xf3, 0x60, 0xdf, 0x03, 0xd4, 0x38, 0x84, 0xdd, 0x72, 0xed, + 0xd8, 0x06, 0xdf, 0x1e, 0x93, 0xbc, 0x03, 0x39, 0xb9, 0xaf, 0x0a, 0x17, 0x72, 0xf2, 0x2e, 0x20, + 0xa4, 0x90, 0x93, 0x77, 0xab, 0xe0, 0xce, 0x73, 0x70, 0x6f, 0xc5, 0x6c, 0xe0, 0xbb, 0x4d, 0xf1, + 0xb7, 0xf7, 0xcb, 0x59, 0xf2, 0xf4, 0x85, 0xb4, 0x3c, 0x51, 0xd6, 0x31, 0x15, 0xcc, 0x78, 0x13, + 0xd6, 0x5c, 0xf2, 0xc8, 0x58, 0xd6, 0x46, 0x3e, 0x29, 0x95, 0xfe, 0x1d, 0x00, 0x00, 0xff, 0xff, + 0x89, 0xc7, 0x62, 0x6f, 0x34, 0x25, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/credentials.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/credentials.pb.go new file mode 100644 index 00000000..4da07f3e --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/credentials.pb.go @@ -0,0 +1,874 @@ +// Code generated by protoc-gen-go. +// source: steammessages_credentials.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CCredentials_TestAvailablePassword_Request struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + ShaDigestPassword []byte `protobuf:"bytes,2,opt,name=sha_digest_password" json:"sha_digest_password,omitempty"` + AccountName *string `protobuf:"bytes,3,opt,name=account_name" json:"account_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_TestAvailablePassword_Request) Reset() { + *m = CCredentials_TestAvailablePassword_Request{} +} +func (m *CCredentials_TestAvailablePassword_Request) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_TestAvailablePassword_Request) ProtoMessage() {} +func (*CCredentials_TestAvailablePassword_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{0} +} + +func (m *CCredentials_TestAvailablePassword_Request) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CCredentials_TestAvailablePassword_Request) GetShaDigestPassword() []byte { + if m != nil { + return m.ShaDigestPassword + } + return nil +} + +func (m *CCredentials_TestAvailablePassword_Request) GetAccountName() string { + if m != nil && m.AccountName != nil { + return *m.AccountName + } + return "" +} + +type CCredentials_TestAvailablePassword_Response struct { + IsValid *bool `protobuf:"varint,3,opt,name=is_valid" json:"is_valid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_TestAvailablePassword_Response) Reset() { + *m = CCredentials_TestAvailablePassword_Response{} +} +func (m *CCredentials_TestAvailablePassword_Response) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_TestAvailablePassword_Response) ProtoMessage() {} +func (*CCredentials_TestAvailablePassword_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{1} +} + +func (m *CCredentials_TestAvailablePassword_Response) GetIsValid() bool { + if m != nil && m.IsValid != nil { + return *m.IsValid + } + return false +} + +type CCredentials_GetSteamGuardDetails_Request struct { + IncludeNewAuthentications *bool `protobuf:"varint,1,opt,name=include_new_authentications,def=1" json:"include_new_authentications,omitempty"` + Webcookie *string `protobuf:"bytes,2,opt,name=webcookie" json:"webcookie,omitempty"` + TimestampMinimumWanted *uint32 `protobuf:"fixed32,3,opt,name=timestamp_minimum_wanted" json:"timestamp_minimum_wanted,omitempty"` + Ipaddress *int32 `protobuf:"varint,4,opt,name=ipaddress" json:"ipaddress,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_GetSteamGuardDetails_Request) Reset() { + *m = CCredentials_GetSteamGuardDetails_Request{} +} +func (m *CCredentials_GetSteamGuardDetails_Request) String() string { return proto.CompactTextString(m) } +func (*CCredentials_GetSteamGuardDetails_Request) ProtoMessage() {} +func (*CCredentials_GetSteamGuardDetails_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{2} +} + +const Default_CCredentials_GetSteamGuardDetails_Request_IncludeNewAuthentications bool = true + +func (m *CCredentials_GetSteamGuardDetails_Request) GetIncludeNewAuthentications() bool { + if m != nil && m.IncludeNewAuthentications != nil { + return *m.IncludeNewAuthentications + } + return Default_CCredentials_GetSteamGuardDetails_Request_IncludeNewAuthentications +} + +func (m *CCredentials_GetSteamGuardDetails_Request) GetWebcookie() string { + if m != nil && m.Webcookie != nil { + return *m.Webcookie + } + return "" +} + +func (m *CCredentials_GetSteamGuardDetails_Request) GetTimestampMinimumWanted() uint32 { + if m != nil && m.TimestampMinimumWanted != nil { + return *m.TimestampMinimumWanted + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Request) GetIpaddress() int32 { + if m != nil && m.Ipaddress != nil { + return *m.Ipaddress + } + return 0 +} + +type CCredentials_GetSteamGuardDetails_Response struct { + IsSteamguardEnabled *bool `protobuf:"varint,1,opt,name=is_steamguard_enabled" json:"is_steamguard_enabled,omitempty"` + TimestampSteamguardEnabled *uint32 `protobuf:"fixed32,2,opt,name=timestamp_steamguard_enabled" json:"timestamp_steamguard_enabled,omitempty"` + DeprecatedNewauthentication []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication `protobuf:"bytes,3,rep,name=deprecated_newauthentication" json:"deprecated_newauthentication,omitempty"` + DeprecatedMachineNameUserchosen *string `protobuf:"bytes,4,opt,name=deprecated_machine_name_userchosen" json:"deprecated_machine_name_userchosen,omitempty"` + DeprecatedTimestampMachineSteamguardEnabled *uint32 `protobuf:"fixed32,5,opt,name=deprecated_timestamp_machine_steamguard_enabled" json:"deprecated_timestamp_machine_steamguard_enabled,omitempty"` + DeprecatedAuthenticationExistsFromGeolocBeforeMintime *bool `protobuf:"varint,6,opt,name=deprecated_authentication_exists_from_geoloc_before_mintime" json:"deprecated_authentication_exists_from_geoloc_before_mintime,omitempty"` + DeprecatedMachineId *uint64 `protobuf:"varint,7,opt,name=deprecated_machine_id" json:"deprecated_machine_id,omitempty"` + SessionData []*CCredentials_GetSteamGuardDetails_Response_SessionData `protobuf:"bytes,8,rep,name=session_data" json:"session_data,omitempty"` + IsTwofactorEnabled *bool `protobuf:"varint,9,opt,name=is_twofactor_enabled" json:"is_twofactor_enabled,omitempty"` + TimestampTwofactorEnabled *uint32 `protobuf:"fixed32,10,opt,name=timestamp_twofactor_enabled" json:"timestamp_twofactor_enabled,omitempty"` + IsPhoneVerified *bool `protobuf:"varint,11,opt,name=is_phone_verified" json:"is_phone_verified,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_GetSteamGuardDetails_Response) Reset() { + *m = CCredentials_GetSteamGuardDetails_Response{} +} +func (m *CCredentials_GetSteamGuardDetails_Response) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_GetSteamGuardDetails_Response) ProtoMessage() {} +func (*CCredentials_GetSteamGuardDetails_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{3} +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetIsSteamguardEnabled() bool { + if m != nil && m.IsSteamguardEnabled != nil { + return *m.IsSteamguardEnabled + } + return false +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetTimestampSteamguardEnabled() uint32 { + if m != nil && m.TimestampSteamguardEnabled != nil { + return *m.TimestampSteamguardEnabled + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedNewauthentication() []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication { + if m != nil { + return m.DeprecatedNewauthentication + } + return nil +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedMachineNameUserchosen() string { + if m != nil && m.DeprecatedMachineNameUserchosen != nil { + return *m.DeprecatedMachineNameUserchosen + } + return "" +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedTimestampMachineSteamguardEnabled() uint32 { + if m != nil && m.DeprecatedTimestampMachineSteamguardEnabled != nil { + return *m.DeprecatedTimestampMachineSteamguardEnabled + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedAuthenticationExistsFromGeolocBeforeMintime() bool { + if m != nil && m.DeprecatedAuthenticationExistsFromGeolocBeforeMintime != nil { + return *m.DeprecatedAuthenticationExistsFromGeolocBeforeMintime + } + return false +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetDeprecatedMachineId() uint64 { + if m != nil && m.DeprecatedMachineId != nil { + return *m.DeprecatedMachineId + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetSessionData() []*CCredentials_GetSteamGuardDetails_Response_SessionData { + if m != nil { + return m.SessionData + } + return nil +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetIsTwofactorEnabled() bool { + if m != nil && m.IsTwofactorEnabled != nil { + return *m.IsTwofactorEnabled + } + return false +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetTimestampTwofactorEnabled() uint32 { + if m != nil && m.TimestampTwofactorEnabled != nil { + return *m.TimestampTwofactorEnabled + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response) GetIsPhoneVerified() bool { + if m != nil && m.IsPhoneVerified != nil { + return *m.IsPhoneVerified + } + return false +} + +type CCredentials_GetSteamGuardDetails_Response_NewAuthentication struct { + TimestampSteamguardEnabled *uint32 `protobuf:"fixed32,1,opt,name=timestamp_steamguard_enabled" json:"timestamp_steamguard_enabled,omitempty"` + IsWebCookie *bool `protobuf:"varint,2,opt,name=is_web_cookie" json:"is_web_cookie,omitempty"` + Ipaddress *int32 `protobuf:"varint,3,opt,name=ipaddress" json:"ipaddress,omitempty"` + GeolocInfo *string `protobuf:"bytes,4,opt,name=geoloc_info" json:"geoloc_info,omitempty"` + IsRemembered *bool `protobuf:"varint,5,opt,name=is_remembered" json:"is_remembered,omitempty"` + MachineNameUserSupplied *string `protobuf:"bytes,6,opt,name=machine_name_user_supplied" json:"machine_name_user_supplied,omitempty"` + Status *int32 `protobuf:"varint,7,opt,name=status" json:"status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) Reset() { + *m = CCredentials_GetSteamGuardDetails_Response_NewAuthentication{} +} +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_GetSteamGuardDetails_Response_NewAuthentication) ProtoMessage() {} +func (*CCredentials_GetSteamGuardDetails_Response_NewAuthentication) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{3, 0} +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetTimestampSteamguardEnabled() uint32 { + if m != nil && m.TimestampSteamguardEnabled != nil { + return *m.TimestampSteamguardEnabled + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetIsWebCookie() bool { + if m != nil && m.IsWebCookie != nil { + return *m.IsWebCookie + } + return false +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetIpaddress() int32 { + if m != nil && m.Ipaddress != nil { + return *m.Ipaddress + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetGeolocInfo() string { + if m != nil && m.GeolocInfo != nil { + return *m.GeolocInfo + } + return "" +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetIsRemembered() bool { + if m != nil && m.IsRemembered != nil { + return *m.IsRemembered + } + return false +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetMachineNameUserSupplied() string { + if m != nil && m.MachineNameUserSupplied != nil { + return *m.MachineNameUserSupplied + } + return "" +} + +func (m *CCredentials_GetSteamGuardDetails_Response_NewAuthentication) GetStatus() int32 { + if m != nil && m.Status != nil { + return *m.Status + } + return 0 +} + +type CCredentials_GetSteamGuardDetails_Response_SessionData struct { + MachineId *uint64 `protobuf:"varint,1,opt,name=machine_id" json:"machine_id,omitempty"` + MachineNameUserchosen *string `protobuf:"bytes,2,opt,name=machine_name_userchosen" json:"machine_name_userchosen,omitempty"` + TimestampMachineSteamguardEnabled *uint32 `protobuf:"fixed32,3,opt,name=timestamp_machine_steamguard_enabled" json:"timestamp_machine_steamguard_enabled,omitempty"` + AuthenticationExistsFromGeolocBeforeMintime *bool `protobuf:"varint,4,opt,name=authentication_exists_from_geoloc_before_mintime" json:"authentication_exists_from_geoloc_before_mintime,omitempty"` + Newauthentication []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication `protobuf:"bytes,5,rep,name=newauthentication" json:"newauthentication,omitempty"` + AuthenticationExistsFromSameIpBeforeMintime *bool `protobuf:"varint,6,opt,name=authentication_exists_from_same_ip_before_mintime" json:"authentication_exists_from_same_ip_before_mintime,omitempty"` + PublicIpv4 *uint32 `protobuf:"varint,7,opt,name=public_ipv4" json:"public_ipv4,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) Reset() { + *m = CCredentials_GetSteamGuardDetails_Response_SessionData{} +} +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_GetSteamGuardDetails_Response_SessionData) ProtoMessage() {} +func (*CCredentials_GetSteamGuardDetails_Response_SessionData) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{3, 1} +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetMachineId() uint64 { + if m != nil && m.MachineId != nil { + return *m.MachineId + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetMachineNameUserchosen() string { + if m != nil && m.MachineNameUserchosen != nil { + return *m.MachineNameUserchosen + } + return "" +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetTimestampMachineSteamguardEnabled() uint32 { + if m != nil && m.TimestampMachineSteamguardEnabled != nil { + return *m.TimestampMachineSteamguardEnabled + } + return 0 +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetAuthenticationExistsFromGeolocBeforeMintime() bool { + if m != nil && m.AuthenticationExistsFromGeolocBeforeMintime != nil { + return *m.AuthenticationExistsFromGeolocBeforeMintime + } + return false +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetNewauthentication() []*CCredentials_GetSteamGuardDetails_Response_NewAuthentication { + if m != nil { + return m.Newauthentication + } + return nil +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetAuthenticationExistsFromSameIpBeforeMintime() bool { + if m != nil && m.AuthenticationExistsFromSameIpBeforeMintime != nil { + return *m.AuthenticationExistsFromSameIpBeforeMintime + } + return false +} + +func (m *CCredentials_GetSteamGuardDetails_Response_SessionData) GetPublicIpv4() uint32 { + if m != nil && m.PublicIpv4 != nil { + return *m.PublicIpv4 + } + return 0 +} + +type CCredentials_NewMachineNotificationDialog_Request struct { + IsApproved *bool `protobuf:"varint,1,opt,name=is_approved" json:"is_approved,omitempty"` + IsWizardComplete *bool `protobuf:"varint,2,opt,name=is_wizard_complete" json:"is_wizard_complete,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_NewMachineNotificationDialog_Request) Reset() { + *m = CCredentials_NewMachineNotificationDialog_Request{} +} +func (m *CCredentials_NewMachineNotificationDialog_Request) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_NewMachineNotificationDialog_Request) ProtoMessage() {} +func (*CCredentials_NewMachineNotificationDialog_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{4} +} + +func (m *CCredentials_NewMachineNotificationDialog_Request) GetIsApproved() bool { + if m != nil && m.IsApproved != nil { + return *m.IsApproved + } + return false +} + +func (m *CCredentials_NewMachineNotificationDialog_Request) GetIsWizardComplete() bool { + if m != nil && m.IsWizardComplete != nil { + return *m.IsWizardComplete + } + return false +} + +type CCredentials_NewMachineNotificationDialog_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_NewMachineNotificationDialog_Response) Reset() { + *m = CCredentials_NewMachineNotificationDialog_Response{} +} +func (m *CCredentials_NewMachineNotificationDialog_Response) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_NewMachineNotificationDialog_Response) ProtoMessage() {} +func (*CCredentials_NewMachineNotificationDialog_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{5} +} + +type CCredentials_ValidateEmailAddress_Request struct { + Stoken *string `protobuf:"bytes,1,opt,name=stoken" json:"stoken,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_ValidateEmailAddress_Request) Reset() { + *m = CCredentials_ValidateEmailAddress_Request{} +} +func (m *CCredentials_ValidateEmailAddress_Request) String() string { return proto.CompactTextString(m) } +func (*CCredentials_ValidateEmailAddress_Request) ProtoMessage() {} +func (*CCredentials_ValidateEmailAddress_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{6} +} + +func (m *CCredentials_ValidateEmailAddress_Request) GetStoken() string { + if m != nil && m.Stoken != nil { + return *m.Stoken + } + return "" +} + +type CCredentials_ValidateEmailAddress_Response struct { + WasValidated *bool `protobuf:"varint,1,opt,name=was_validated" json:"was_validated,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_ValidateEmailAddress_Response) Reset() { + *m = CCredentials_ValidateEmailAddress_Response{} +} +func (m *CCredentials_ValidateEmailAddress_Response) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_ValidateEmailAddress_Response) ProtoMessage() {} +func (*CCredentials_ValidateEmailAddress_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{7} +} + +func (m *CCredentials_ValidateEmailAddress_Response) GetWasValidated() bool { + if m != nil && m.WasValidated != nil { + return *m.WasValidated + } + return false +} + +type CCredentials_SteamGuardPhishingReport_Request struct { + ParamString *string `protobuf:"bytes,1,opt,name=param_string" json:"param_string,omitempty"` + IpaddressActual *uint32 `protobuf:"varint,2,opt,name=ipaddress_actual" json:"ipaddress_actual,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_SteamGuardPhishingReport_Request) Reset() { + *m = CCredentials_SteamGuardPhishingReport_Request{} +} +func (m *CCredentials_SteamGuardPhishingReport_Request) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_SteamGuardPhishingReport_Request) ProtoMessage() {} +func (*CCredentials_SteamGuardPhishingReport_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{8} +} + +func (m *CCredentials_SteamGuardPhishingReport_Request) GetParamString() string { + if m != nil && m.ParamString != nil { + return *m.ParamString + } + return "" +} + +func (m *CCredentials_SteamGuardPhishingReport_Request) GetIpaddressActual() uint32 { + if m != nil && m.IpaddressActual != nil { + return *m.IpaddressActual + } + return 0 +} + +type CCredentials_SteamGuardPhishingReport_Response struct { + IpaddressLoginattempt *uint32 `protobuf:"varint,1,opt,name=ipaddress_loginattempt" json:"ipaddress_loginattempt,omitempty"` + CountrynameLoginattempt *string `protobuf:"bytes,2,opt,name=countryname_loginattempt" json:"countryname_loginattempt,omitempty"` + StatenameLoginattempt *string `protobuf:"bytes,3,opt,name=statename_loginattempt" json:"statename_loginattempt,omitempty"` + CitynameLoginattempt *string `protobuf:"bytes,4,opt,name=cityname_loginattempt" json:"cityname_loginattempt,omitempty"` + IpaddressActual *uint32 `protobuf:"varint,5,opt,name=ipaddress_actual" json:"ipaddress_actual,omitempty"` + CountrynameActual *string `protobuf:"bytes,6,opt,name=countryname_actual" json:"countryname_actual,omitempty"` + StatenameActual *string `protobuf:"bytes,7,opt,name=statename_actual" json:"statename_actual,omitempty"` + CitynameActual *string `protobuf:"bytes,8,opt,name=cityname_actual" json:"cityname_actual,omitempty"` + SteamguardCode *string `protobuf:"bytes,9,opt,name=steamguard_code" json:"steamguard_code,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) Reset() { + *m = CCredentials_SteamGuardPhishingReport_Response{} +} +func (m *CCredentials_SteamGuardPhishingReport_Response) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_SteamGuardPhishingReport_Response) ProtoMessage() {} +func (*CCredentials_SteamGuardPhishingReport_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{9} +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetIpaddressLoginattempt() uint32 { + if m != nil && m.IpaddressLoginattempt != nil { + return *m.IpaddressLoginattempt + } + return 0 +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetCountrynameLoginattempt() string { + if m != nil && m.CountrynameLoginattempt != nil { + return *m.CountrynameLoginattempt + } + return "" +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetStatenameLoginattempt() string { + if m != nil && m.StatenameLoginattempt != nil { + return *m.StatenameLoginattempt + } + return "" +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetCitynameLoginattempt() string { + if m != nil && m.CitynameLoginattempt != nil { + return *m.CitynameLoginattempt + } + return "" +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetIpaddressActual() uint32 { + if m != nil && m.IpaddressActual != nil { + return *m.IpaddressActual + } + return 0 +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetCountrynameActual() string { + if m != nil && m.CountrynameActual != nil { + return *m.CountrynameActual + } + return "" +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetStatenameActual() string { + if m != nil && m.StatenameActual != nil { + return *m.StatenameActual + } + return "" +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetCitynameActual() string { + if m != nil && m.CitynameActual != nil { + return *m.CitynameActual + } + return "" +} + +func (m *CCredentials_SteamGuardPhishingReport_Response) GetSteamguardCode() string { + if m != nil && m.SteamguardCode != nil { + return *m.SteamguardCode + } + return "" +} + +type CCredentials_AccountLockRequest_Request struct { + ParamString *string `protobuf:"bytes,1,opt,name=param_string" json:"param_string,omitempty"` + IpaddressActual *uint32 `protobuf:"varint,2,opt,name=ipaddress_actual" json:"ipaddress_actual,omitempty"` + QueryOnly *bool `protobuf:"varint,3,opt,name=query_only" json:"query_only,omitempty"` + EmailMessageType *int32 `protobuf:"varint,4,opt,name=email_message_type" json:"email_message_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_AccountLockRequest_Request) Reset() { + *m = CCredentials_AccountLockRequest_Request{} +} +func (m *CCredentials_AccountLockRequest_Request) String() string { return proto.CompactTextString(m) } +func (*CCredentials_AccountLockRequest_Request) ProtoMessage() {} +func (*CCredentials_AccountLockRequest_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{10} +} + +func (m *CCredentials_AccountLockRequest_Request) GetParamString() string { + if m != nil && m.ParamString != nil { + return *m.ParamString + } + return "" +} + +func (m *CCredentials_AccountLockRequest_Request) GetIpaddressActual() uint32 { + if m != nil && m.IpaddressActual != nil { + return *m.IpaddressActual + } + return 0 +} + +func (m *CCredentials_AccountLockRequest_Request) GetQueryOnly() bool { + if m != nil && m.QueryOnly != nil { + return *m.QueryOnly + } + return false +} + +func (m *CCredentials_AccountLockRequest_Request) GetEmailMessageType() int32 { + if m != nil && m.EmailMessageType != nil { + return *m.EmailMessageType + } + return 0 +} + +type CCredentials_AccountLockRequest_Response struct { + Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"` + AccountAlreadyLocked *bool `protobuf:"varint,2,opt,name=account_already_locked" json:"account_already_locked,omitempty"` + ExpiredLink *bool `protobuf:"varint,3,opt,name=expired_link" json:"expired_link,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_AccountLockRequest_Response) Reset() { + *m = CCredentials_AccountLockRequest_Response{} +} +func (m *CCredentials_AccountLockRequest_Response) String() string { return proto.CompactTextString(m) } +func (*CCredentials_AccountLockRequest_Response) ProtoMessage() {} +func (*CCredentials_AccountLockRequest_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{11} +} + +func (m *CCredentials_AccountLockRequest_Response) GetSuccess() bool { + if m != nil && m.Success != nil { + return *m.Success + } + return false +} + +func (m *CCredentials_AccountLockRequest_Response) GetAccountAlreadyLocked() bool { + if m != nil && m.AccountAlreadyLocked != nil { + return *m.AccountAlreadyLocked + } + return false +} + +func (m *CCredentials_AccountLockRequest_Response) GetExpiredLink() bool { + if m != nil && m.ExpiredLink != nil { + return *m.ExpiredLink + } + return false +} + +type CCredentials_LastCredentialChangeTime_Request struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_LastCredentialChangeTime_Request) Reset() { + *m = CCredentials_LastCredentialChangeTime_Request{} +} +func (m *CCredentials_LastCredentialChangeTime_Request) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_LastCredentialChangeTime_Request) ProtoMessage() {} +func (*CCredentials_LastCredentialChangeTime_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{12} +} + +type CCredentials_LastCredentialChangeTime_Response struct { + TimestampLastPasswordChange *uint32 `protobuf:"fixed32,1,opt,name=timestamp_last_password_change" json:"timestamp_last_password_change,omitempty"` + TimestampLastEmailChange *uint32 `protobuf:"fixed32,2,opt,name=timestamp_last_email_change" json:"timestamp_last_email_change,omitempty"` + TimestampLastPasswordReset *uint32 `protobuf:"fixed32,3,opt,name=timestamp_last_password_reset" json:"timestamp_last_password_reset,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_LastCredentialChangeTime_Response) Reset() { + *m = CCredentials_LastCredentialChangeTime_Response{} +} +func (m *CCredentials_LastCredentialChangeTime_Response) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_LastCredentialChangeTime_Response) ProtoMessage() {} +func (*CCredentials_LastCredentialChangeTime_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{13} +} + +func (m *CCredentials_LastCredentialChangeTime_Response) GetTimestampLastPasswordChange() uint32 { + if m != nil && m.TimestampLastPasswordChange != nil { + return *m.TimestampLastPasswordChange + } + return 0 +} + +func (m *CCredentials_LastCredentialChangeTime_Response) GetTimestampLastEmailChange() uint32 { + if m != nil && m.TimestampLastEmailChange != nil { + return *m.TimestampLastEmailChange + } + return 0 +} + +func (m *CCredentials_LastCredentialChangeTime_Response) GetTimestampLastPasswordReset() uint32 { + if m != nil && m.TimestampLastPasswordReset != nil { + return *m.TimestampLastPasswordReset + } + return 0 +} + +type CCredentials_GetAccountAuthSecret_Request struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_GetAccountAuthSecret_Request) Reset() { + *m = CCredentials_GetAccountAuthSecret_Request{} +} +func (m *CCredentials_GetAccountAuthSecret_Request) String() string { return proto.CompactTextString(m) } +func (*CCredentials_GetAccountAuthSecret_Request) ProtoMessage() {} +func (*CCredentials_GetAccountAuthSecret_Request) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{14} +} + +type CCredentials_GetAccountAuthSecret_Response struct { + SecretId *int32 `protobuf:"varint,1,opt,name=secret_id" json:"secret_id,omitempty"` + Secret []byte `protobuf:"bytes,2,opt,name=secret" json:"secret,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CCredentials_GetAccountAuthSecret_Response) Reset() { + *m = CCredentials_GetAccountAuthSecret_Response{} +} +func (m *CCredentials_GetAccountAuthSecret_Response) String() string { + return proto.CompactTextString(m) +} +func (*CCredentials_GetAccountAuthSecret_Response) ProtoMessage() {} +func (*CCredentials_GetAccountAuthSecret_Response) Descriptor() ([]byte, []int) { + return credentials_fileDescriptor0, []int{15} +} + +func (m *CCredentials_GetAccountAuthSecret_Response) GetSecretId() int32 { + if m != nil && m.SecretId != nil { + return *m.SecretId + } + return 0 +} + +func (m *CCredentials_GetAccountAuthSecret_Response) GetSecret() []byte { + if m != nil { + return m.Secret + } + return nil +} + +func init() { + proto.RegisterType((*CCredentials_TestAvailablePassword_Request)(nil), "CCredentials_TestAvailablePassword_Request") + proto.RegisterType((*CCredentials_TestAvailablePassword_Response)(nil), "CCredentials_TestAvailablePassword_Response") + proto.RegisterType((*CCredentials_GetSteamGuardDetails_Request)(nil), "CCredentials_GetSteamGuardDetails_Request") + proto.RegisterType((*CCredentials_GetSteamGuardDetails_Response)(nil), "CCredentials_GetSteamGuardDetails_Response") + proto.RegisterType((*CCredentials_GetSteamGuardDetails_Response_NewAuthentication)(nil), "CCredentials_GetSteamGuardDetails_Response.NewAuthentication") + proto.RegisterType((*CCredentials_GetSteamGuardDetails_Response_SessionData)(nil), "CCredentials_GetSteamGuardDetails_Response.SessionData") + proto.RegisterType((*CCredentials_NewMachineNotificationDialog_Request)(nil), "CCredentials_NewMachineNotificationDialog_Request") + proto.RegisterType((*CCredentials_NewMachineNotificationDialog_Response)(nil), "CCredentials_NewMachineNotificationDialog_Response") + proto.RegisterType((*CCredentials_ValidateEmailAddress_Request)(nil), "CCredentials_ValidateEmailAddress_Request") + proto.RegisterType((*CCredentials_ValidateEmailAddress_Response)(nil), "CCredentials_ValidateEmailAddress_Response") + proto.RegisterType((*CCredentials_SteamGuardPhishingReport_Request)(nil), "CCredentials_SteamGuardPhishingReport_Request") + proto.RegisterType((*CCredentials_SteamGuardPhishingReport_Response)(nil), "CCredentials_SteamGuardPhishingReport_Response") + proto.RegisterType((*CCredentials_AccountLockRequest_Request)(nil), "CCredentials_AccountLockRequest_Request") + proto.RegisterType((*CCredentials_AccountLockRequest_Response)(nil), "CCredentials_AccountLockRequest_Response") + proto.RegisterType((*CCredentials_LastCredentialChangeTime_Request)(nil), "CCredentials_LastCredentialChangeTime_Request") + proto.RegisterType((*CCredentials_LastCredentialChangeTime_Response)(nil), "CCredentials_LastCredentialChangeTime_Response") + proto.RegisterType((*CCredentials_GetAccountAuthSecret_Request)(nil), "CCredentials_GetAccountAuthSecret_Request") + proto.RegisterType((*CCredentials_GetAccountAuthSecret_Response)(nil), "CCredentials_GetAccountAuthSecret_Response") +} + +var credentials_fileDescriptor0 = []byte{ + // 1482 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x5d, 0x6f, 0x14, 0xd5, + 0x1b, 0xcf, 0x94, 0xbe, 0xec, 0x3e, 0xa5, 0x7f, 0xe8, 0x40, 0x61, 0x59, 0x0a, 0x4c, 0x06, 0xfe, + 0xb6, 0xd0, 0x3a, 0x48, 0x25, 0x41, 0x25, 0xc6, 0x94, 0x56, 0x09, 0x06, 0x90, 0x00, 0x51, 0xef, + 0x4e, 0x4e, 0x67, 0x4e, 0x77, 0x4f, 0x3a, 0x33, 0x67, 0x98, 0x39, 0xb3, 0x4b, 0x4d, 0x4c, 0xc4, + 0x3b, 0xbc, 0xf0, 0xce, 0x0b, 0x13, 0x2f, 0x8d, 0x5f, 0xc0, 0xe8, 0x17, 0xf0, 0x2b, 0xf8, 0x25, + 0xbc, 0x32, 0x7e, 0x03, 0x9f, 0x73, 0xe6, 0xec, 0xfb, 0x6c, 0xbb, 0x4b, 0xbc, 0xdc, 0x39, 0xcf, + 0xcb, 0xef, 0xf9, 0x3d, 0xaf, 0x0b, 0x1b, 0x99, 0x64, 0x34, 0x8a, 0x58, 0x96, 0xd1, 0x06, 0xcb, + 0x88, 0x9f, 0xb2, 0x80, 0xc5, 0x92, 0xd3, 0x30, 0xf3, 0xf4, 0x8b, 0x1f, 0x72, 0xfc, 0xed, 0x25, + 0xa9, 0x90, 0xa2, 0xbe, 0x39, 0x28, 0x9c, 0xc7, 0x7c, 0x9f, 0xb3, 0x80, 0xec, 0xd1, 0x8c, 0x8d, + 0x4a, 0xbb, 0x2f, 0xe0, 0xc6, 0xce, 0x4e, 0xcf, 0x1e, 0x79, 0xce, 0x32, 0xb9, 0xdd, 0xa2, 0x3c, + 0xa4, 0x7b, 0x21, 0x7b, 0x42, 0xb3, 0xac, 0x2d, 0xd2, 0x80, 0x3c, 0x65, 0x2f, 0x72, 0x7c, 0xb0, + 0x4f, 0x43, 0x25, 0x31, 0xdf, 0x6a, 0x96, 0x63, 0xad, 0x57, 0xed, 0x8b, 0x70, 0x26, 0x6b, 0x52, + 0x12, 0x70, 0xf4, 0x25, 0x49, 0xf7, 0x71, 0x06, 0x1f, 0x4f, 0xda, 0x67, 0xe1, 0x24, 0xf5, 0x7d, + 0x91, 0xc7, 0x92, 0xc4, 0x34, 0x62, 0xb5, 0x13, 0x4a, 0xc5, 0xfd, 0x08, 0x36, 0x26, 0x72, 0x99, + 0x25, 0x22, 0xce, 0x98, 0xf2, 0xc9, 0x33, 0xd2, 0xa2, 0x21, 0x0f, 0xb4, 0x81, 0x8a, 0xfb, 0xf7, + 0x0c, 0x5c, 0x1f, 0xb0, 0x70, 0x9f, 0xc9, 0x67, 0x2a, 0xb2, 0xfb, 0x39, 0x4d, 0x83, 0x5d, 0x26, + 0xd1, 0x56, 0xd6, 0xc5, 0x9c, 0xc3, 0x45, 0x1e, 0xfb, 0x61, 0x1e, 0x30, 0x12, 0xb3, 0x36, 0xa1, + 0xb9, 0x6c, 0x2a, 0x3d, 0x9f, 0x4a, 0x8e, 0xf6, 0x75, 0x18, 0x95, 0x0f, 0x66, 0x65, 0x9a, 0xb3, + 0x7b, 0x9f, 0x7e, 0xfb, 0x5b, 0xed, 0x93, 0x2f, 0x9a, 0x0c, 0x25, 0x52, 0x47, 0xa4, 0x4e, 0x2c, + 0xa4, 0x23, 0x85, 0x93, 0x88, 0x24, 0x0f, 0xa9, 0x64, 0x0e, 0x7e, 0x77, 0xd0, 0xc6, 0xa0, 0x09, + 0x07, 0xe9, 0x0d, 0x03, 0x87, 0xc7, 0xfa, 0x39, 0xed, 0xc0, 0xfe, 0xc1, 0x82, 0x6a, 0x9b, 0xed, + 0xf9, 0x42, 0x1c, 0x70, 0xa6, 0xf9, 0xa8, 0xde, 0x7b, 0x65, 0xa1, 0x83, 0xaf, 0x9f, 0xa3, 0x58, + 0x9e, 0xb1, 0x74, 0x2d, 0x73, 0x34, 0x6a, 0x47, 0xc3, 0x76, 0x22, 0xea, 0x37, 0x79, 0xcc, 0x1c, + 0x65, 0xdd, 0x29, 0xd4, 0x3c, 0xe7, 0xc1, 0xbe, 0x93, 0xa0, 0x49, 0xf4, 0xb6, 0xe9, 0x70, 0xb9, + 0x16, 0x86, 0xce, 0x9e, 0x56, 0x0e, 0x14, 0xae, 0x06, 0x93, 0xda, 0xa7, 0x31, 0xd6, 0x31, 0xf0, + 0x60, 0x17, 0xc1, 0xa8, 0x4c, 0x07, 0x8e, 0xd8, 0xd7, 0x02, 0xdb, 0x8f, 0x9c, 0x0c, 0xeb, 0x01, + 0xc1, 0x7a, 0xb6, 0x03, 0x35, 0xc9, 0xb1, 0x3a, 0x24, 0x8d, 0x12, 0x12, 0xf1, 0x98, 0x47, 0x79, + 0x44, 0xda, 0x34, 0x96, 0xac, 0xa0, 0x77, 0xc1, 0x5e, 0x86, 0x2a, 0x4f, 0x68, 0x10, 0xa0, 0xdf, + 0xac, 0x36, 0x8b, 0x9f, 0xe6, 0xdc, 0xbf, 0x2a, 0x43, 0x65, 0x32, 0x86, 0x71, 0x13, 0xfb, 0x25, + 0x58, 0xc1, 0x94, 0xe9, 0x62, 0x6b, 0x28, 0x01, 0xc2, 0x62, 0x95, 0xdb, 0xa2, 0x66, 0x2a, 0xf6, + 0x35, 0x58, 0xed, 0x41, 0x28, 0x91, 0x9a, 0xd1, 0x30, 0x7c, 0x58, 0x0d, 0x18, 0x06, 0x8f, 0x2c, + 0x63, 0xf9, 0x8e, 0xd0, 0x8e, 0x60, 0x4f, 0xac, 0x2f, 0x6e, 0x7d, 0xe8, 0x4d, 0x8e, 0xcb, 0x7b, + 0xcc, 0xda, 0xdb, 0x03, 0x46, 0xec, 0x1b, 0xe0, 0xf6, 0x39, 0x31, 0x0c, 0xea, 0x62, 0x25, 0x8a, + 0x55, 0xbf, 0x29, 0x90, 0x7b, 0x4d, 0x42, 0xd5, 0xbe, 0x03, 0x37, 0xfb, 0x64, 0xfb, 0x48, 0x34, + 0x5a, 0x25, 0x91, 0xcc, 0xe9, 0x48, 0x76, 0xe0, 0x6e, 0x9f, 0xe2, 0x60, 0x18, 0x84, 0xbd, 0xe4, + 0x99, 0xcc, 0xc8, 0x7e, 0x2a, 0x22, 0xd2, 0x60, 0x22, 0x14, 0x3e, 0xd9, 0x63, 0xfb, 0x22, 0x65, + 0x2a, 0x39, 0xca, 0x49, 0x6d, 0x5e, 0x93, 0x86, 0x9c, 0x96, 0x20, 0xc5, 0x9e, 0x58, 0xc0, 0xe7, + 0x59, 0xfb, 0x11, 0x9c, 0x34, 0x29, 0x26, 0x01, 0x95, 0xb4, 0x56, 0xd1, 0xec, 0xdc, 0x99, 0x86, + 0x9d, 0x67, 0x85, 0xfe, 0x2e, 0xaa, 0xdb, 0xab, 0x70, 0x16, 0x33, 0x28, 0xdb, 0x62, 0x9f, 0xfa, + 0x52, 0xa4, 0xdd, 0x80, 0xaa, 0x1a, 0xcb, 0x55, 0xb8, 0xd8, 0x0b, 0x7f, 0x54, 0x08, 0x74, 0xd4, + 0x17, 0x60, 0x19, 0x4d, 0x24, 0x4d, 0x81, 0x30, 0x5b, 0x2c, 0xd5, 0x53, 0xa8, 0xb6, 0xa8, 0xf4, + 0xeb, 0x7f, 0x58, 0xb0, 0x3c, 0x9a, 0x8b, 0xe3, 0xca, 0xc2, 0xd2, 0x66, 0x57, 0x60, 0x09, 0xcd, + 0x62, 0x67, 0x91, 0xbe, 0xd6, 0xaa, 0x0c, 0x16, 0xad, 0xaa, 0xe3, 0x39, 0xfb, 0x0c, 0x2c, 0x1a, + 0x42, 0x79, 0xbc, 0x2f, 0x4c, 0x12, 0x0b, 0xf5, 0x94, 0x45, 0x2c, 0xda, 0x63, 0xa9, 0x49, 0x51, + 0xc5, 0x76, 0xa1, 0x3e, 0x92, 0x7c, 0x92, 0xe5, 0x49, 0x12, 0x2a, 0xd4, 0xf3, 0x5a, 0xf5, 0x7f, + 0x30, 0x8f, 0xd8, 0x64, 0x9e, 0x69, 0xca, 0xe7, 0xea, 0x7f, 0xce, 0xc0, 0x62, 0x3f, 0x67, 0x36, + 0x40, 0x5f, 0x5a, 0x2c, 0x9d, 0x96, 0x2b, 0x70, 0x7e, 0x5c, 0x51, 0xe9, 0x91, 0x60, 0x6f, 0xc2, + 0xb5, 0x89, 0x2a, 0xa9, 0x68, 0xcd, 0xf7, 0xe0, 0x9d, 0xa9, 0xcb, 0x67, 0x56, 0x07, 0xf8, 0x25, + 0x2c, 0x8f, 0xb6, 0xd0, 0xdc, 0x7f, 0xd1, 0x42, 0xef, 0xc3, 0xad, 0x23, 0x30, 0x65, 0x2a, 0x6a, + 0x9e, 0x94, 0xd7, 0x34, 0x66, 0x28, 0xc9, 0xf7, 0x42, 0x8e, 0x19, 0x4a, 0x5a, 0xb7, 0x35, 0xad, + 0x4b, 0x6e, 0x00, 0xb7, 0x06, 0xf0, 0xa0, 0xc7, 0x47, 0x05, 0x2f, 0x8f, 0x85, 0xc4, 0x2a, 0x2a, + 0x9c, 0xec, 0xe2, 0x9b, 0x68, 0x74, 0x87, 0x3c, 0x5a, 0xc2, 0xb4, 0xd2, 0x04, 0x97, 0x5a, 0xab, + 0x3b, 0x67, 0xea, 0x60, 0xab, 0x52, 0xe1, 0x5f, 0x29, 0x22, 0x7d, 0x11, 0x25, 0x21, 0x93, 0xa6, + 0x5e, 0xdc, 0xdb, 0xb0, 0x35, 0x8d, 0x97, 0x22, 0x7a, 0xf7, 0xee, 0xd0, 0xe2, 0xf9, 0x5c, 0x6d, + 0x25, 0x6c, 0xc8, 0x8f, 0x23, 0x64, 0x69, 0xbb, 0xa8, 0xbe, 0x2e, 0x26, 0x5d, 0x2f, 0xe2, 0x00, + 0x53, 0xad, 0x57, 0xa5, 0xbb, 0x33, 0x34, 0x43, 0xc7, 0x28, 0x9b, 0x19, 0x8a, 0x85, 0xda, 0xa6, + 0x66, 0xef, 0xa9, 0x96, 0x2f, 0x62, 0x72, 0x09, 0xbc, 0x3d, 0x60, 0xa4, 0x97, 0xaa, 0x27, 0x4d, + 0x9e, 0x21, 0xfe, 0xc6, 0x53, 0x96, 0x88, 0x54, 0x76, 0x51, 0xe0, 0x0e, 0x4e, 0x68, 0x4a, 0x31, + 0x13, 0x32, 0xc5, 0x57, 0xb3, 0xb6, 0x6b, 0x70, 0xba, 0xdb, 0x2e, 0x04, 0xbb, 0x37, 0xa7, 0xa1, + 0x26, 0x66, 0xc9, 0xfd, 0x75, 0x06, 0xbc, 0x49, 0x3d, 0x18, 0xa8, 0x97, 0xe1, 0x5c, 0xcf, 0x18, + 0xf2, 0xc5, 0x63, 0x2a, 0x25, 0x8b, 0x12, 0xa9, 0x9d, 0x2d, 0xa9, 0x95, 0xa3, 0x8f, 0x80, 0xf4, + 0x50, 0xf7, 0xc0, 0x80, 0x44, 0xd1, 0x05, 0x68, 0x41, 0xb5, 0x16, 0x1b, 0x7d, 0xd7, 0x27, 0x83, + 0x1a, 0x7e, 0x3e, 0x97, 0x25, 0xea, 0xb3, 0x63, 0xa3, 0x99, 0xd3, 0xae, 0xb1, 0x04, 0xfa, 0x5d, + 0x9b, 0xb7, 0xf9, 0x8e, 0x56, 0xcf, 0xa9, 0x79, 0x59, 0xd0, 0x2f, 0xe7, 0xe1, 0x54, 0xd7, 0x9d, + 0x79, 0xa8, 0x74, 0x1e, 0xfa, 0x7a, 0xd3, 0x17, 0x01, 0xd3, 0x13, 0xb1, 0xea, 0xbe, 0xb6, 0x60, + 0x6d, 0x80, 0xb5, 0xed, 0xe2, 0xee, 0x79, 0x28, 0xfc, 0x03, 0x93, 0x89, 0x37, 0xcd, 0x88, 0x9a, + 0x2b, 0xa8, 0x98, 0x1e, 0x12, 0x11, 0x87, 0x87, 0xc5, 0x09, 0xa4, 0xe2, 0x62, 0xaa, 0x6c, 0x88, + 0xb9, 0xf3, 0x88, 0x3c, 0x4c, 0x98, 0x59, 0xd6, 0x2f, 0x60, 0xfd, 0x78, 0x28, 0x26, 0x75, 0xa7, + 0x60, 0x21, 0xcb, 0x7d, 0x5f, 0x0d, 0xcd, 0xa2, 0x67, 0x30, 0x13, 0x9d, 0x93, 0x8d, 0x86, 0x29, + 0xde, 0x10, 0x87, 0x48, 0xb8, 0x7f, 0x60, 0xb6, 0x72, 0x45, 0x81, 0x67, 0x2f, 0x13, 0x8e, 0xe6, + 0x49, 0xc8, 0xe3, 0x03, 0x73, 0x91, 0xdd, 0x1c, 0xaa, 0xca, 0x87, 0x34, 0x93, 0xbd, 0xdf, 0x3b, + 0x4d, 0x1a, 0x37, 0xd8, 0x73, 0xec, 0xfb, 0x0e, 0x07, 0xee, 0xcf, 0xd6, 0x50, 0x95, 0x1d, 0xa1, + 0x61, 0xa0, 0xbe, 0x05, 0x97, 0x7b, 0x93, 0x32, 0xa4, 0x7d, 0xd7, 0x26, 0xf1, 0xb5, 0xb8, 0x59, + 0x10, 0x03, 0xcb, 0x49, 0xcb, 0x15, 0x4c, 0x19, 0xa1, 0xe2, 0xb8, 0xf8, 0x3f, 0x5c, 0x1a, 0x67, + 0x4c, 0x9d, 0x5b, 0x45, 0xdd, 0x2d, 0xb8, 0x1b, 0xa3, 0x87, 0xa6, 0x61, 0x53, 0x0d, 0xc1, 0x67, + 0x0c, 0x2f, 0xf1, 0x6e, 0x5e, 0xdd, 0xcf, 0x46, 0x6f, 0xa4, 0x32, 0x61, 0x13, 0x0e, 0x2e, 0xac, + 0xac, 0xf8, 0x64, 0x96, 0xc5, 0x9c, 0x1e, 0x18, 0xfa, 0x53, 0x71, 0x3e, 0x6f, 0xfd, 0x53, 0x85, + 0xc5, 0x3e, 0x83, 0xf6, 0xf7, 0x16, 0xac, 0x94, 0x1e, 0xcb, 0xf6, 0x86, 0x37, 0xf9, 0x11, 0x5f, + 0xdf, 0xf4, 0xa6, 0x38, 0xbf, 0xdd, 0x3a, 0x9e, 0xac, 0xe7, 0x4a, 0x65, 0x3c, 0xfb, 0x3b, 0x0b, + 0xce, 0x96, 0xad, 0x0b, 0xfb, 0x86, 0x37, 0xf1, 0x7d, 0x5e, 0xdf, 0x98, 0x62, 0xfd, 0xb8, 0x17, + 0x10, 0xcd, 0x4a, 0x99, 0x88, 0x67, 0xff, 0x6e, 0x81, 0x7b, 0xd4, 0x14, 0x47, 0x1b, 0x79, 0x28, + 0xed, 0x2d, 0x6f, 0xea, 0xed, 0x52, 0x7f, 0xd7, 0x7b, 0x83, 0x5d, 0xb1, 0x86, 0x50, 0xaf, 0x1e, + 0x0f, 0xc8, 0xb3, 0x7f, 0x42, 0x16, 0xcb, 0x76, 0xc1, 0x30, 0x8b, 0x47, 0x2d, 0x9b, 0x61, 0x16, + 0x8f, 0xdc, 0x2d, 0xee, 0x06, 0x42, 0x5b, 0xeb, 0x88, 0x38, 0x34, 0x76, 0x74, 0x87, 0x38, 0x66, + 0xfa, 0x38, 0x0d, 0xde, 0x62, 0xb1, 0x43, 0x1d, 0xbd, 0xbc, 0xec, 0x1f, 0x2d, 0xa8, 0x8d, 0xdb, + 0x01, 0xb6, 0xe7, 0x4d, 0xb5, 0x8d, 0xea, 0x37, 0xa7, 0xdc, 0x2d, 0xee, 0x2a, 0x42, 0x1d, 0xef, + 0xfe, 0x95, 0x05, 0xf6, 0xe8, 0x78, 0xb3, 0xd7, 0xbd, 0x09, 0x67, 0x71, 0xfd, 0xba, 0x37, 0xe9, + 0xa8, 0x74, 0xcf, 0x21, 0x92, 0x32, 0x67, 0xbf, 0x58, 0x70, 0x19, 0x2b, 0xb2, 0x6c, 0x78, 0x75, + 0xda, 0xc1, 0xf3, 0xa6, 0x9a, 0x8e, 0xc3, 0x2c, 0x1d, 0x3b, 0x1b, 0xdd, 0xab, 0x88, 0xed, 0xca, + 0xd1, 0x20, 0x3c, 0xfb, 0x75, 0xd1, 0xad, 0x23, 0x33, 0xa9, 0xa4, 0x5b, 0xc7, 0x0e, 0xb9, 0x92, + 0x6e, 0x1d, 0x3f, 0xe3, 0xdc, 0x1a, 0xc2, 0x2a, 0x75, 0x59, 0x3f, 0x8f, 0x2f, 0x67, 0xfa, 0x0c, + 0xe1, 0xff, 0xd3, 0xb4, 0xc5, 0x7d, 0x76, 0xef, 0xc4, 0x37, 0x96, 0xf5, 0x6f, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x3c, 0x6e, 0x05, 0xde, 0xf0, 0x10, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/deviceauth.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/deviceauth.pb.go new file mode 100644 index 00000000..ee21b081 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/deviceauth.pb.go @@ -0,0 +1,694 @@ +// Code generated by protoc-gen-go. +// source: steammessages_deviceauth.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CDeviceAuth_GetOwnAuthorizedDevices_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + IncludeCanceled *bool `protobuf:"varint,2,opt,name=include_canceled" json:"include_canceled,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) Reset() { + *m = CDeviceAuth_GetOwnAuthorizedDevices_Request{} +} +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetOwnAuthorizedDevices_Request) ProtoMessage() {} +func (*CDeviceAuth_GetOwnAuthorizedDevices_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{0} +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Request) GetIncludeCanceled() bool { + if m != nil && m.IncludeCanceled != nil { + return *m.IncludeCanceled + } + return false +} + +type CDeviceAuth_GetOwnAuthorizedDevices_Response struct { + Devices []*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device `protobuf:"bytes,1,rep,name=devices" json:"devices,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response) Reset() { + *m = CDeviceAuth_GetOwnAuthorizedDevices_Response{} +} +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetOwnAuthorizedDevices_Response) ProtoMessage() {} +func (*CDeviceAuth_GetOwnAuthorizedDevices_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{1} +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response) GetDevices() []*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device { + if m != nil { + return m.Devices + } + return nil +} + +type CDeviceAuth_GetOwnAuthorizedDevices_Response_Device struct { + AuthDeviceToken *uint64 `protobuf:"fixed64,1,opt,name=auth_device_token" json:"auth_device_token,omitempty"` + DeviceName *string `protobuf:"bytes,2,opt,name=device_name" json:"device_name,omitempty"` + IsPending *bool `protobuf:"varint,3,opt,name=is_pending" json:"is_pending,omitempty"` + IsCanceled *bool `protobuf:"varint,4,opt,name=is_canceled" json:"is_canceled,omitempty"` + LastTimeUsed *uint32 `protobuf:"varint,5,opt,name=last_time_used" json:"last_time_used,omitempty"` + LastBorrowerId *uint64 `protobuf:"fixed64,6,opt,name=last_borrower_id" json:"last_borrower_id,omitempty"` + LastAppPlayed *uint32 `protobuf:"varint,7,opt,name=last_app_played" json:"last_app_played,omitempty"` + IsLimited *bool `protobuf:"varint,8,opt,name=is_limited" json:"is_limited,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) Reset() { + *m = CDeviceAuth_GetOwnAuthorizedDevices_Response_Device{} +} +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) ProtoMessage() {} +func (*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{1, 0} +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetAuthDeviceToken() uint64 { + if m != nil && m.AuthDeviceToken != nil { + return *m.AuthDeviceToken + } + return 0 +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetDeviceName() string { + if m != nil && m.DeviceName != nil { + return *m.DeviceName + } + return "" +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetIsPending() bool { + if m != nil && m.IsPending != nil { + return *m.IsPending + } + return false +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetIsCanceled() bool { + if m != nil && m.IsCanceled != nil { + return *m.IsCanceled + } + return false +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetLastTimeUsed() uint32 { + if m != nil && m.LastTimeUsed != nil { + return *m.LastTimeUsed + } + return 0 +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetLastBorrowerId() uint64 { + if m != nil && m.LastBorrowerId != nil { + return *m.LastBorrowerId + } + return 0 +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetLastAppPlayed() uint32 { + if m != nil && m.LastAppPlayed != nil { + return *m.LastAppPlayed + } + return 0 +} + +func (m *CDeviceAuth_GetOwnAuthorizedDevices_Response_Device) GetIsLimited() bool { + if m != nil && m.IsLimited != nil { + return *m.IsLimited + } + return false +} + +type CDeviceAuth_AcceptAuthorizationRequest_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + AuthDeviceToken *uint64 `protobuf:"fixed64,2,opt,name=auth_device_token" json:"auth_device_token,omitempty"` + AuthCode *uint64 `protobuf:"fixed64,3,opt,name=auth_code" json:"auth_code,omitempty"` + FromSteamid *uint64 `protobuf:"fixed64,4,opt,name=from_steamid" json:"from_steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) Reset() { + *m = CDeviceAuth_AcceptAuthorizationRequest_Request{} +} +func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_AcceptAuthorizationRequest_Request) ProtoMessage() {} +func (*CDeviceAuth_AcceptAuthorizationRequest_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{2} +} + +func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetAuthDeviceToken() uint64 { + if m != nil && m.AuthDeviceToken != nil { + return *m.AuthDeviceToken + } + return 0 +} + +func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetAuthCode() uint64 { + if m != nil && m.AuthCode != nil { + return *m.AuthCode + } + return 0 +} + +func (m *CDeviceAuth_AcceptAuthorizationRequest_Request) GetFromSteamid() uint64 { + if m != nil && m.FromSteamid != nil { + return *m.FromSteamid + } + return 0 +} + +type CDeviceAuth_AcceptAuthorizationRequest_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_AcceptAuthorizationRequest_Response) Reset() { + *m = CDeviceAuth_AcceptAuthorizationRequest_Response{} +} +func (m *CDeviceAuth_AcceptAuthorizationRequest_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_AcceptAuthorizationRequest_Response) ProtoMessage() {} +func (*CDeviceAuth_AcceptAuthorizationRequest_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{3} +} + +type CDeviceAuth_AuthorizeRemoteDevice_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + AuthDeviceToken *uint64 `protobuf:"fixed64,2,opt,name=auth_device_token" json:"auth_device_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) Reset() { + *m = CDeviceAuth_AuthorizeRemoteDevice_Request{} +} +func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) String() string { return proto.CompactTextString(m) } +func (*CDeviceAuth_AuthorizeRemoteDevice_Request) ProtoMessage() {} +func (*CDeviceAuth_AuthorizeRemoteDevice_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{4} +} + +func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_AuthorizeRemoteDevice_Request) GetAuthDeviceToken() uint64 { + if m != nil && m.AuthDeviceToken != nil { + return *m.AuthDeviceToken + } + return 0 +} + +type CDeviceAuth_AuthorizeRemoteDevice_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_AuthorizeRemoteDevice_Response) Reset() { + *m = CDeviceAuth_AuthorizeRemoteDevice_Response{} +} +func (m *CDeviceAuth_AuthorizeRemoteDevice_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_AuthorizeRemoteDevice_Response) ProtoMessage() {} +func (*CDeviceAuth_AuthorizeRemoteDevice_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{5} +} + +type CDeviceAuth_DeauthorizeRemoteDevice_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + AuthDeviceToken *uint64 `protobuf:"fixed64,2,opt,name=auth_device_token" json:"auth_device_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) Reset() { + *m = CDeviceAuth_DeauthorizeRemoteDevice_Request{} +} +func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_DeauthorizeRemoteDevice_Request) ProtoMessage() {} +func (*CDeviceAuth_DeauthorizeRemoteDevice_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{6} +} + +func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_DeauthorizeRemoteDevice_Request) GetAuthDeviceToken() uint64 { + if m != nil && m.AuthDeviceToken != nil { + return *m.AuthDeviceToken + } + return 0 +} + +type CDeviceAuth_DeauthorizeRemoteDevice_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_DeauthorizeRemoteDevice_Response) Reset() { + *m = CDeviceAuth_DeauthorizeRemoteDevice_Response{} +} +func (m *CDeviceAuth_DeauthorizeRemoteDevice_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_DeauthorizeRemoteDevice_Response) ProtoMessage() {} +func (*CDeviceAuth_DeauthorizeRemoteDevice_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{7} +} + +type CDeviceAuth_GetUsedAuthorizedDevices_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Request) Reset() { + *m = CDeviceAuth_GetUsedAuthorizedDevices_Request{} +} +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Request) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetUsedAuthorizedDevices_Request) ProtoMessage() {} +func (*CDeviceAuth_GetUsedAuthorizedDevices_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{8} +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CDeviceAuth_GetUsedAuthorizedDevices_Response struct { + Devices []*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device `protobuf:"bytes,1,rep,name=devices" json:"devices,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response) Reset() { + *m = CDeviceAuth_GetUsedAuthorizedDevices_Response{} +} +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetUsedAuthorizedDevices_Response) ProtoMessage() {} +func (*CDeviceAuth_GetUsedAuthorizedDevices_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{9} +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response) GetDevices() []*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device { + if m != nil { + return m.Devices + } + return nil +} + +type CDeviceAuth_GetUsedAuthorizedDevices_Response_Device struct { + AuthDeviceToken *uint64 `protobuf:"fixed64,1,opt,name=auth_device_token" json:"auth_device_token,omitempty"` + DeviceName *string `protobuf:"bytes,2,opt,name=device_name" json:"device_name,omitempty"` + OwnerSteamid *uint64 `protobuf:"fixed64,3,opt,name=owner_steamid" json:"owner_steamid,omitempty"` + LastTimeUsed *uint32 `protobuf:"varint,4,opt,name=last_time_used" json:"last_time_used,omitempty"` + LastAppPlayed *uint32 `protobuf:"varint,5,opt,name=last_app_played" json:"last_app_played,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) Reset() { + *m = CDeviceAuth_GetUsedAuthorizedDevices_Response_Device{} +} +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) ProtoMessage() {} +func (*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{9, 0} +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetAuthDeviceToken() uint64 { + if m != nil && m.AuthDeviceToken != nil { + return *m.AuthDeviceToken + } + return 0 +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetDeviceName() string { + if m != nil && m.DeviceName != nil { + return *m.DeviceName + } + return "" +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetOwnerSteamid() uint64 { + if m != nil && m.OwnerSteamid != nil { + return *m.OwnerSteamid + } + return 0 +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetLastTimeUsed() uint32 { + if m != nil && m.LastTimeUsed != nil { + return *m.LastTimeUsed + } + return 0 +} + +func (m *CDeviceAuth_GetUsedAuthorizedDevices_Response_Device) GetLastAppPlayed() uint32 { + if m != nil && m.LastAppPlayed != nil { + return *m.LastAppPlayed + } + return 0 +} + +type CDeviceAuth_GetAuthorizedBorrowers_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + IncludeCanceled *bool `protobuf:"varint,2,opt,name=include_canceled" json:"include_canceled,omitempty"` + IncludePending *bool `protobuf:"varint,3,opt,name=include_pending" json:"include_pending,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) Reset() { + *m = CDeviceAuth_GetAuthorizedBorrowers_Request{} +} +func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetAuthorizedBorrowers_Request) ProtoMessage() {} +func (*CDeviceAuth_GetAuthorizedBorrowers_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{10} +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) GetIncludeCanceled() bool { + if m != nil && m.IncludeCanceled != nil { + return *m.IncludeCanceled + } + return false +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Request) GetIncludePending() bool { + if m != nil && m.IncludePending != nil { + return *m.IncludePending + } + return false +} + +type CDeviceAuth_GetAuthorizedBorrowers_Response struct { + Borrowers []*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower `protobuf:"bytes,1,rep,name=borrowers" json:"borrowers,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response) Reset() { + *m = CDeviceAuth_GetAuthorizedBorrowers_Response{} +} +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetAuthorizedBorrowers_Response) ProtoMessage() {} +func (*CDeviceAuth_GetAuthorizedBorrowers_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{11} +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response) GetBorrowers() []*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower { + if m != nil { + return m.Borrowers + } + return nil +} + +type CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + IsPending *bool `protobuf:"varint,2,opt,name=is_pending" json:"is_pending,omitempty"` + IsCanceled *bool `protobuf:"varint,3,opt,name=is_canceled" json:"is_canceled,omitempty"` + TimeCreated *uint32 `protobuf:"varint,4,opt,name=time_created" json:"time_created,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) Reset() { + *m = CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower{} +} +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) ProtoMessage() {} +func (*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{11, 0} +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetIsPending() bool { + if m != nil && m.IsPending != nil { + return *m.IsPending + } + return false +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetIsCanceled() bool { + if m != nil && m.IsCanceled != nil { + return *m.IsCanceled + } + return false +} + +func (m *CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +type CDeviceAuth_AddAuthorizedBorrowers_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + SteamidBorrower []uint64 `protobuf:"fixed64,2,rep,name=steamid_borrower" json:"steamid_borrower,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) Reset() { + *m = CDeviceAuth_AddAuthorizedBorrowers_Request{} +} +func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_AddAuthorizedBorrowers_Request) ProtoMessage() {} +func (*CDeviceAuth_AddAuthorizedBorrowers_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{12} +} + +func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_AddAuthorizedBorrowers_Request) GetSteamidBorrower() []uint64 { + if m != nil { + return m.SteamidBorrower + } + return nil +} + +type CDeviceAuth_AddAuthorizedBorrowers_Response struct { + SecondsToWait *int32 `protobuf:"varint,1,opt,name=seconds_to_wait" json:"seconds_to_wait,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_AddAuthorizedBorrowers_Response) Reset() { + *m = CDeviceAuth_AddAuthorizedBorrowers_Response{} +} +func (m *CDeviceAuth_AddAuthorizedBorrowers_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_AddAuthorizedBorrowers_Response) ProtoMessage() {} +func (*CDeviceAuth_AddAuthorizedBorrowers_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{13} +} + +func (m *CDeviceAuth_AddAuthorizedBorrowers_Response) GetSecondsToWait() int32 { + if m != nil && m.SecondsToWait != nil { + return *m.SecondsToWait + } + return 0 +} + +type CDeviceAuth_RemoveAuthorizedBorrowers_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + SteamidBorrower []uint64 `protobuf:"fixed64,2,rep,name=steamid_borrower" json:"steamid_borrower,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) Reset() { + *m = CDeviceAuth_RemoveAuthorizedBorrowers_Request{} +} +func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_RemoveAuthorizedBorrowers_Request) ProtoMessage() {} +func (*CDeviceAuth_RemoveAuthorizedBorrowers_Request) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{14} +} + +func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Request) GetSteamidBorrower() []uint64 { + if m != nil { + return m.SteamidBorrower + } + return nil +} + +type CDeviceAuth_RemoveAuthorizedBorrowers_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Response) Reset() { + *m = CDeviceAuth_RemoveAuthorizedBorrowers_Response{} +} +func (m *CDeviceAuth_RemoveAuthorizedBorrowers_Response) String() string { + return proto.CompactTextString(m) +} +func (*CDeviceAuth_RemoveAuthorizedBorrowers_Response) ProtoMessage() {} +func (*CDeviceAuth_RemoveAuthorizedBorrowers_Response) Descriptor() ([]byte, []int) { + return deviceauth_fileDescriptor0, []int{15} +} + +func init() { + proto.RegisterType((*CDeviceAuth_GetOwnAuthorizedDevices_Request)(nil), "CDeviceAuth_GetOwnAuthorizedDevices_Request") + proto.RegisterType((*CDeviceAuth_GetOwnAuthorizedDevices_Response)(nil), "CDeviceAuth_GetOwnAuthorizedDevices_Response") + proto.RegisterType((*CDeviceAuth_GetOwnAuthorizedDevices_Response_Device)(nil), "CDeviceAuth_GetOwnAuthorizedDevices_Response.Device") + proto.RegisterType((*CDeviceAuth_AcceptAuthorizationRequest_Request)(nil), "CDeviceAuth_AcceptAuthorizationRequest_Request") + proto.RegisterType((*CDeviceAuth_AcceptAuthorizationRequest_Response)(nil), "CDeviceAuth_AcceptAuthorizationRequest_Response") + proto.RegisterType((*CDeviceAuth_AuthorizeRemoteDevice_Request)(nil), "CDeviceAuth_AuthorizeRemoteDevice_Request") + proto.RegisterType((*CDeviceAuth_AuthorizeRemoteDevice_Response)(nil), "CDeviceAuth_AuthorizeRemoteDevice_Response") + proto.RegisterType((*CDeviceAuth_DeauthorizeRemoteDevice_Request)(nil), "CDeviceAuth_DeauthorizeRemoteDevice_Request") + proto.RegisterType((*CDeviceAuth_DeauthorizeRemoteDevice_Response)(nil), "CDeviceAuth_DeauthorizeRemoteDevice_Response") + proto.RegisterType((*CDeviceAuth_GetUsedAuthorizedDevices_Request)(nil), "CDeviceAuth_GetUsedAuthorizedDevices_Request") + proto.RegisterType((*CDeviceAuth_GetUsedAuthorizedDevices_Response)(nil), "CDeviceAuth_GetUsedAuthorizedDevices_Response") + proto.RegisterType((*CDeviceAuth_GetUsedAuthorizedDevices_Response_Device)(nil), "CDeviceAuth_GetUsedAuthorizedDevices_Response.Device") + proto.RegisterType((*CDeviceAuth_GetAuthorizedBorrowers_Request)(nil), "CDeviceAuth_GetAuthorizedBorrowers_Request") + proto.RegisterType((*CDeviceAuth_GetAuthorizedBorrowers_Response)(nil), "CDeviceAuth_GetAuthorizedBorrowers_Response") + proto.RegisterType((*CDeviceAuth_GetAuthorizedBorrowers_Response_Borrower)(nil), "CDeviceAuth_GetAuthorizedBorrowers_Response.Borrower") + proto.RegisterType((*CDeviceAuth_AddAuthorizedBorrowers_Request)(nil), "CDeviceAuth_AddAuthorizedBorrowers_Request") + proto.RegisterType((*CDeviceAuth_AddAuthorizedBorrowers_Response)(nil), "CDeviceAuth_AddAuthorizedBorrowers_Response") + proto.RegisterType((*CDeviceAuth_RemoveAuthorizedBorrowers_Request)(nil), "CDeviceAuth_RemoveAuthorizedBorrowers_Request") + proto.RegisterType((*CDeviceAuth_RemoveAuthorizedBorrowers_Response)(nil), "CDeviceAuth_RemoveAuthorizedBorrowers_Response") +} + +var deviceauth_fileDescriptor0 = []byte{ + // 934 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x56, 0xdf, 0x4e, 0x3b, 0x45, + 0x14, 0xce, 0xb6, 0x50, 0x60, 0x10, 0x91, 0x51, 0xa0, 0xec, 0x85, 0x4e, 0x56, 0x2f, 0x10, 0xca, + 0x80, 0x04, 0xe3, 0xff, 0x3f, 0x20, 0xa2, 0x17, 0x26, 0x26, 0x18, 0xa3, 0x72, 0xb3, 0x99, 0xee, + 0x0e, 0x74, 0x62, 0xbb, 0xbb, 0xee, 0x4c, 0x69, 0xf0, 0x8a, 0x98, 0xf8, 0x12, 0xfa, 0x06, 0x5e, + 0x19, 0x13, 0xa2, 0x89, 0x5e, 0xf8, 0x0e, 0xbe, 0x8d, 0x57, 0xbf, 0xb3, 0xb3, 0xb3, 0x85, 0x6d, + 0x77, 0x4b, 0xb7, 0xe1, 0xaa, 0x9b, 0x73, 0xce, 0x9c, 0xf9, 0xce, 0x99, 0xf3, 0x7d, 0xa7, 0x68, + 0x47, 0x2a, 0xce, 0x7a, 0x3d, 0x2e, 0x25, 0xbb, 0xe2, 0xd2, 0xf5, 0xf9, 0xb5, 0xf0, 0x38, 0xeb, + 0xab, 0x0e, 0xd5, 0x0e, 0xaf, 0x2b, 0x78, 0xa0, 0x68, 0x14, 0x87, 0x2a, 0xb4, 0x5b, 0xf9, 0xd8, + 0x7e, 0x20, 0x2e, 0x05, 0xf7, 0xdd, 0x36, 0x93, 0x7c, 0x3c, 0xda, 0xf9, 0x16, 0xed, 0x7e, 0x72, + 0xaa, 0xd3, 0x1d, 0x43, 0x3a, 0xf7, 0x33, 0xae, 0xbe, 0x1c, 0x04, 0xc9, 0x67, 0x18, 0x8b, 0x1f, + 0xb9, 0x9f, 0xba, 0xa4, 0x7b, 0xce, 0x7f, 0xe8, 0x73, 0xa9, 0xf0, 0x2a, 0x5a, 0xd0, 0x39, 0x84, + 0xdf, 0xb4, 0x88, 0xb5, 0xdd, 0xc0, 0x4d, 0xf4, 0x82, 0x08, 0xbc, 0x6e, 0xdf, 0xe7, 0xae, 0xc7, + 0x02, 0x8f, 0x77, 0xb9, 0xdf, 0xac, 0x81, 0x67, 0xd1, 0xf9, 0xab, 0x86, 0x5a, 0xd3, 0xa5, 0x96, + 0x51, 0x18, 0x48, 0x8e, 0x3f, 0x45, 0x0b, 0x69, 0x61, 0x12, 0x72, 0xd7, 0xb7, 0x97, 0x0f, 0x8f, + 0x68, 0x95, 0xf3, 0x34, 0x35, 0xd8, 0xff, 0x5a, 0xa8, 0x91, 0x7e, 0xe2, 0x2d, 0xb4, 0x96, 0x34, + 0xc9, 0xf4, 0xcb, 0x55, 0xe1, 0xf7, 0x3c, 0x30, 0xb8, 0x5f, 0x44, 0xcb, 0xc6, 0x1a, 0xb0, 0x1e, + 0xd7, 0x90, 0x97, 0x30, 0x46, 0x48, 0x48, 0x37, 0xe2, 0x81, 0x2f, 0x82, 0xab, 0x66, 0x3d, 0x29, + 0x23, 0x09, 0x04, 0xdb, 0xb0, 0xb6, 0x39, 0x6d, 0xdc, 0x40, 0xcf, 0x77, 0x99, 0x54, 0xae, 0x12, + 0x3d, 0xee, 0xf6, 0x25, 0xd8, 0xe7, 0xc1, 0xbe, 0x92, 0x74, 0x43, 0xdb, 0xdb, 0x61, 0x1c, 0x87, + 0x03, 0x1e, 0xbb, 0xd0, 0xa7, 0x86, 0xbe, 0x6f, 0x13, 0xad, 0x6a, 0x0f, 0x8b, 0x22, 0x37, 0xea, + 0xb2, 0x1b, 0x38, 0xb2, 0xa0, 0x8f, 0xa4, 0x77, 0x76, 0x45, 0x4f, 0x28, 0xb0, 0x2d, 0xea, 0xd6, + 0xfd, 0x6c, 0xa1, 0x5c, 0xe9, 0xc7, 0x9e, 0xc7, 0x23, 0x95, 0x95, 0xce, 0x94, 0x08, 0x03, 0xf3, + 0x20, 0xe5, 0x0f, 0x53, 0x58, 0x7b, 0x4d, 0xbb, 0xd6, 0xd0, 0x92, 0x76, 0x79, 0xa1, 0xcf, 0x75, + 0x95, 0x0d, 0xfc, 0x12, 0x7a, 0xee, 0x32, 0x0e, 0x7b, 0x6e, 0x96, 0x23, 0x29, 0xb3, 0xe1, 0xbc, + 0x81, 0xf6, 0xa7, 0x86, 0x91, 0x3e, 0x82, 0xf3, 0x0d, 0x7a, 0x3d, 0x77, 0x24, 0x7b, 0xae, 0x73, + 0xde, 0x0b, 0x15, 0x4f, 0x3d, 0xb3, 0x80, 0x76, 0x5a, 0x68, 0x67, 0x9a, 0xc4, 0x06, 0xc6, 0x77, + 0xf9, 0xb1, 0x3e, 0xd5, 0x64, 0x79, 0x1a, 0x20, 0x34, 0x3f, 0xd6, 0xe5, 0xa9, 0x0d, 0x94, 0x8f, + 0xc6, 0x68, 0xf0, 0x35, 0x0c, 0xcc, 0xf4, 0x14, 0x73, 0xfe, 0xb7, 0xd0, 0xde, 0x94, 0x19, 0x0c, + 0x93, 0xce, 0x46, 0x99, 0xf4, 0x26, 0xad, 0x94, 0x20, 0xa3, 0xd2, 0xed, 0xec, 0x54, 0x5a, 0x47, + 0x2b, 0xe1, 0x20, 0x00, 0x06, 0x64, 0xb5, 0xa4, 0x73, 0x36, 0x4e, 0x9c, 0x39, 0xcd, 0x82, 0x02, + 0x7a, 0x68, 0x46, 0x39, 0x51, 0xfe, 0xd9, 0x01, 0xfa, 0x3d, 0xec, 0x13, 0xc3, 0xb2, 0x59, 0xe4, + 0x29, 0xb9, 0x31, 0xf3, 0xe4, 0x08, 0xef, 0xfc, 0x67, 0x8d, 0x49, 0x62, 0xf1, 0x95, 0xa6, 0xd9, + 0x9f, 0xa3, 0xa5, 0x8c, 0xee, 0xa5, 0xed, 0x9e, 0x94, 0x80, 0x66, 0x26, 0xfb, 0x02, 0x2d, 0x66, + 0xdf, 0xe3, 0x95, 0xe4, 0xb5, 0xa9, 0x56, 0xa4, 0x4d, 0xa9, 0x60, 0x01, 0x95, 0x75, 0x77, 0xbd, + 0x98, 0x33, 0x95, 0x35, 0x18, 0x78, 0x99, 0xa7, 0x8f, 0xef, 0x57, 0xed, 0xa3, 0x31, 0x0c, 0xb5, + 0x0d, 0x30, 0xd4, 0x61, 0x3a, 0xcf, 0xf2, 0xdd, 0x2a, 0x4d, 0x6c, 0xba, 0x05, 0x6d, 0x97, 0xdc, + 0x0b, 0x03, 0x5f, 0xc2, 0x0c, 0xb9, 0x03, 0x26, 0x94, 0xbe, 0x61, 0xde, 0xb9, 0xc8, 0x0f, 0x79, + 0xc2, 0xa5, 0x6b, 0xfe, 0x44, 0x18, 0x0f, 0xf2, 0x72, 0x3a, 0x29, 0x77, 0x0a, 0xf3, 0xf0, 0xcf, + 0x65, 0x84, 0xee, 0x4f, 0xe0, 0x5f, 0x2c, 0xb4, 0x59, 0xb2, 0x7f, 0x70, 0x8b, 0x56, 0x58, 0xa0, + 0xf6, 0x5e, 0xa5, 0x9d, 0xe6, 0x38, 0x3f, 0xdd, 0x35, 0x5f, 0x86, 0x28, 0xd2, 0x15, 0x52, 0x91, + 0xf0, 0x92, 0x0c, 0xc5, 0xc6, 0x27, 0x86, 0xe2, 0xf8, 0xce, 0x42, 0x76, 0xb9, 0x34, 0xe3, 0xfd, + 0x8a, 0xab, 0xc4, 0x3e, 0xa0, 0x55, 0x45, 0xff, 0x08, 0x50, 0x1e, 0xa4, 0x81, 0x84, 0x05, 0x43, + 0x8c, 0x3a, 0x98, 0xc4, 0x69, 0x34, 0x69, 0xdf, 0x80, 0x2f, 0x54, 0x1d, 0x1e, 0x13, 0x20, 0x7e, + 0x2c, 0xf1, 0x6f, 0x16, 0x5a, 0x2f, 0x94, 0x71, 0xbc, 0x43, 0xa7, 0xde, 0x21, 0xf6, 0x2e, 0xad, + 0xb0, 0x16, 0xde, 0x06, 0xa0, 0x47, 0xc3, 0x18, 0x02, 0x0a, 0x05, 0xf0, 0x92, 0x40, 0xd3, 0x4c, + 0xa2, 0x3a, 0x4c, 0x91, 0x0e, 0x93, 0xc4, 0x10, 0x2d, 0x43, 0x8f, 0x7f, 0x85, 0x09, 0x28, 0x91, + 0xfa, 0x91, 0x09, 0x78, 0x64, 0xd7, 0x8c, 0x4c, 0xc0, 0xa3, 0xeb, 0xe3, 0x55, 0x80, 0xfc, 0xca, + 0x39, 0xbf, 0x06, 0xc1, 0xd5, 0x78, 0x0d, 0xd0, 0x5c, 0x8f, 0xf1, 0xdf, 0x16, 0x6a, 0x96, 0xa9, + 0x3a, 0xde, 0xa3, 0x55, 0xf6, 0x8f, 0x4d, 0xab, 0xed, 0x0a, 0xe7, 0x63, 0x00, 0xf8, 0xfe, 0xe4, + 0x11, 0xd5, 0x0f, 0x4e, 0x52, 0x5d, 0x27, 0x86, 0x9b, 0x3e, 0xb9, 0x82, 0x6d, 0x21, 0x09, 0xa0, + 0xff, 0xc3, 0x42, 0x1b, 0xc5, 0x22, 0x89, 0x77, 0xe9, 0xf4, 0xea, 0x6f, 0xb7, 0xaa, 0xc8, 0xae, + 0xf3, 0x01, 0xe0, 0x7e, 0xe7, 0x21, 0x6e, 0x3d, 0x95, 0xe9, 0x04, 0x80, 0xa4, 0x1a, 0x9c, 0x80, + 0xef, 0xe1, 0x48, 0x0f, 0x6b, 0xc2, 0xbf, 0x03, 0xe8, 0x62, 0xb1, 0x1b, 0x01, 0x3d, 0x59, 0x6a, + 0x47, 0x40, 0x3f, 0x22, 0x9f, 0xce, 0x7b, 0x00, 0xfa, 0x2d, 0x08, 0x2a, 0x07, 0x6b, 0xfe, 0x49, + 0x16, 0x09, 0xc5, 0x3f, 0x16, 0xda, 0x2a, 0xd5, 0x3e, 0x4c, 0x69, 0x25, 0xfd, 0xb5, 0xf7, 0x2b, + 0x6a, 0xaa, 0xf3, 0x21, 0x60, 0x7f, 0x37, 0x8d, 0x9b, 0x05, 0xbe, 0xfd, 0x1a, 0x9c, 0x27, 0x5f, + 0x88, 0x76, 0xcc, 0xe2, 0x1b, 0xf2, 0x55, 0x87, 0xc5, 0x09, 0x3f, 0x25, 0x57, 0x0a, 0x7e, 0x25, + 0x7c, 0xc4, 0x49, 0xd8, 0x49, 0xfd, 0xd6, 0xb2, 0x9e, 0x05, 0x00, 0x00, 0xff, 0xff, 0x27, 0xc5, + 0x15, 0xba, 0x30, 0x0d, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/gamenotifications.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/gamenotifications.pb.go new file mode 100644 index 00000000..a3678022 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/gamenotifications.pb.go @@ -0,0 +1,850 @@ +// Code generated by protoc-gen-go. +// source: steammessages_gamenotifications.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CGameNotifications_Variable struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_Variable) Reset() { *m = CGameNotifications_Variable{} } +func (m *CGameNotifications_Variable) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_Variable) ProtoMessage() {} +func (*CGameNotifications_Variable) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{0} } + +func (m *CGameNotifications_Variable) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *CGameNotifications_Variable) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CGameNotifications_LocalizedText struct { + Token *string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` + Variables []*CGameNotifications_Variable `protobuf:"bytes,2,rep,name=variables" json:"variables,omitempty"` + RenderedText *string `protobuf:"bytes,3,opt,name=rendered_text" json:"rendered_text,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_LocalizedText) Reset() { *m = CGameNotifications_LocalizedText{} } +func (m *CGameNotifications_LocalizedText) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_LocalizedText) ProtoMessage() {} +func (*CGameNotifications_LocalizedText) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{1} +} + +func (m *CGameNotifications_LocalizedText) GetToken() string { + if m != nil && m.Token != nil { + return *m.Token + } + return "" +} + +func (m *CGameNotifications_LocalizedText) GetVariables() []*CGameNotifications_Variable { + if m != nil { + return m.Variables + } + return nil +} + +func (m *CGameNotifications_LocalizedText) GetRenderedText() string { + if m != nil && m.RenderedText != nil { + return *m.RenderedText + } + return "" +} + +type CGameNotifications_UserStatus struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + State *string `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"` + Title *CGameNotifications_LocalizedText `protobuf:"bytes,3,opt,name=title" json:"title,omitempty"` + Message *CGameNotifications_LocalizedText `protobuf:"bytes,4,opt,name=message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_UserStatus) Reset() { *m = CGameNotifications_UserStatus{} } +func (m *CGameNotifications_UserStatus) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_UserStatus) ProtoMessage() {} +func (*CGameNotifications_UserStatus) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{2} } + +func (m *CGameNotifications_UserStatus) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CGameNotifications_UserStatus) GetState() string { + if m != nil && m.State != nil { + return *m.State + } + return "" +} + +func (m *CGameNotifications_UserStatus) GetTitle() *CGameNotifications_LocalizedText { + if m != nil { + return m.Title + } + return nil +} + +func (m *CGameNotifications_UserStatus) GetMessage() *CGameNotifications_LocalizedText { + if m != nil { + return m.Message + } + return nil +} + +type CGameNotifications_CreateSession_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Context *uint64 `protobuf:"varint,2,opt,name=context" json:"context,omitempty"` + Title *CGameNotifications_LocalizedText `protobuf:"bytes,3,opt,name=title" json:"title,omitempty"` + Users []*CGameNotifications_UserStatus `protobuf:"bytes,4,rep,name=users" json:"users,omitempty"` + Steamid *uint64 `protobuf:"fixed64,5,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_CreateSession_Request) Reset() { + *m = CGameNotifications_CreateSession_Request{} +} +func (m *CGameNotifications_CreateSession_Request) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_CreateSession_Request) ProtoMessage() {} +func (*CGameNotifications_CreateSession_Request) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{3} +} + +func (m *CGameNotifications_CreateSession_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CGameNotifications_CreateSession_Request) GetContext() uint64 { + if m != nil && m.Context != nil { + return *m.Context + } + return 0 +} + +func (m *CGameNotifications_CreateSession_Request) GetTitle() *CGameNotifications_LocalizedText { + if m != nil { + return m.Title + } + return nil +} + +func (m *CGameNotifications_CreateSession_Request) GetUsers() []*CGameNotifications_UserStatus { + if m != nil { + return m.Users + } + return nil +} + +func (m *CGameNotifications_CreateSession_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CGameNotifications_CreateSession_Response struct { + Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_CreateSession_Response) Reset() { + *m = CGameNotifications_CreateSession_Response{} +} +func (m *CGameNotifications_CreateSession_Response) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_CreateSession_Response) ProtoMessage() {} +func (*CGameNotifications_CreateSession_Response) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{4} +} + +func (m *CGameNotifications_CreateSession_Response) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +type CGameNotifications_DeleteSession_Request struct { + Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + Steamid *uint64 `protobuf:"fixed64,3,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_DeleteSession_Request) Reset() { + *m = CGameNotifications_DeleteSession_Request{} +} +func (m *CGameNotifications_DeleteSession_Request) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_DeleteSession_Request) ProtoMessage() {} +func (*CGameNotifications_DeleteSession_Request) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{5} +} + +func (m *CGameNotifications_DeleteSession_Request) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +func (m *CGameNotifications_DeleteSession_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CGameNotifications_DeleteSession_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CGameNotifications_DeleteSession_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_DeleteSession_Response) Reset() { + *m = CGameNotifications_DeleteSession_Response{} +} +func (m *CGameNotifications_DeleteSession_Response) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_DeleteSession_Response) ProtoMessage() {} +func (*CGameNotifications_DeleteSession_Response) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{6} +} + +type CGameNotifications_UpdateSession_Request struct { + Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + Title *CGameNotifications_LocalizedText `protobuf:"bytes,3,opt,name=title" json:"title,omitempty"` + Users []*CGameNotifications_UserStatus `protobuf:"bytes,4,rep,name=users" json:"users,omitempty"` + Steamid *uint64 `protobuf:"fixed64,6,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_UpdateSession_Request) Reset() { + *m = CGameNotifications_UpdateSession_Request{} +} +func (m *CGameNotifications_UpdateSession_Request) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_UpdateSession_Request) ProtoMessage() {} +func (*CGameNotifications_UpdateSession_Request) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{7} +} + +func (m *CGameNotifications_UpdateSession_Request) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +func (m *CGameNotifications_UpdateSession_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CGameNotifications_UpdateSession_Request) GetTitle() *CGameNotifications_LocalizedText { + if m != nil { + return m.Title + } + return nil +} + +func (m *CGameNotifications_UpdateSession_Request) GetUsers() []*CGameNotifications_UserStatus { + if m != nil { + return m.Users + } + return nil +} + +func (m *CGameNotifications_UpdateSession_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CGameNotifications_UpdateSession_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_UpdateSession_Response) Reset() { + *m = CGameNotifications_UpdateSession_Response{} +} +func (m *CGameNotifications_UpdateSession_Response) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_UpdateSession_Response) ProtoMessage() {} +func (*CGameNotifications_UpdateSession_Response) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{8} +} + +type CGameNotifications_EnumerateSessions_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + IncludeAllUserMessages *bool `protobuf:"varint,3,opt,name=include_all_user_messages" json:"include_all_user_messages,omitempty"` + IncludeAuthUserMessage *bool `protobuf:"varint,4,opt,name=include_auth_user_message" json:"include_auth_user_message,omitempty"` + Language *string `protobuf:"bytes,5,opt,name=language" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_EnumerateSessions_Request) Reset() { + *m = CGameNotifications_EnumerateSessions_Request{} +} +func (m *CGameNotifications_EnumerateSessions_Request) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_EnumerateSessions_Request) ProtoMessage() {} +func (*CGameNotifications_EnumerateSessions_Request) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{9} +} + +func (m *CGameNotifications_EnumerateSessions_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CGameNotifications_EnumerateSessions_Request) GetIncludeAllUserMessages() bool { + if m != nil && m.IncludeAllUserMessages != nil { + return *m.IncludeAllUserMessages + } + return false +} + +func (m *CGameNotifications_EnumerateSessions_Request) GetIncludeAuthUserMessage() bool { + if m != nil && m.IncludeAuthUserMessage != nil { + return *m.IncludeAuthUserMessage + } + return false +} + +func (m *CGameNotifications_EnumerateSessions_Request) GetLanguage() string { + if m != nil && m.Language != nil { + return *m.Language + } + return "" +} + +type CGameNotifications_Session struct { + Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"` + Appid *uint64 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + Context *uint64 `protobuf:"varint,3,opt,name=context" json:"context,omitempty"` + Title *CGameNotifications_LocalizedText `protobuf:"bytes,4,opt,name=title" json:"title,omitempty"` + TimeCreated *uint32 `protobuf:"varint,5,opt,name=time_created" json:"time_created,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,6,opt,name=time_updated" json:"time_updated,omitempty"` + UserStatus []*CGameNotifications_UserStatus `protobuf:"bytes,7,rep,name=user_status" json:"user_status,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_Session) Reset() { *m = CGameNotifications_Session{} } +func (m *CGameNotifications_Session) String() string { return proto.CompactTextString(m) } +func (*CGameNotifications_Session) ProtoMessage() {} +func (*CGameNotifications_Session) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{10} } + +func (m *CGameNotifications_Session) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +func (m *CGameNotifications_Session) GetAppid() uint64 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CGameNotifications_Session) GetContext() uint64 { + if m != nil && m.Context != nil { + return *m.Context + } + return 0 +} + +func (m *CGameNotifications_Session) GetTitle() *CGameNotifications_LocalizedText { + if m != nil { + return m.Title + } + return nil +} + +func (m *CGameNotifications_Session) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *CGameNotifications_Session) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +func (m *CGameNotifications_Session) GetUserStatus() []*CGameNotifications_UserStatus { + if m != nil { + return m.UserStatus + } + return nil +} + +type CGameNotifications_EnumerateSessions_Response struct { + Sessions []*CGameNotifications_Session `protobuf:"bytes,1,rep,name=sessions" json:"sessions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_EnumerateSessions_Response) Reset() { + *m = CGameNotifications_EnumerateSessions_Response{} +} +func (m *CGameNotifications_EnumerateSessions_Response) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_EnumerateSessions_Response) ProtoMessage() {} +func (*CGameNotifications_EnumerateSessions_Response) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{11} +} + +func (m *CGameNotifications_EnumerateSessions_Response) GetSessions() []*CGameNotifications_Session { + if m != nil { + return m.Sessions + } + return nil +} + +type CGameNotifications_GetSessionDetails_Request struct { + Sessions []*CGameNotifications_GetSessionDetails_Request_RequestedSession `protobuf:"bytes,1,rep,name=sessions" json:"sessions,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + Language *string `protobuf:"bytes,3,opt,name=language" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_GetSessionDetails_Request) Reset() { + *m = CGameNotifications_GetSessionDetails_Request{} +} +func (m *CGameNotifications_GetSessionDetails_Request) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_GetSessionDetails_Request) ProtoMessage() {} +func (*CGameNotifications_GetSessionDetails_Request) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{12} +} + +func (m *CGameNotifications_GetSessionDetails_Request) GetSessions() []*CGameNotifications_GetSessionDetails_Request_RequestedSession { + if m != nil { + return m.Sessions + } + return nil +} + +func (m *CGameNotifications_GetSessionDetails_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CGameNotifications_GetSessionDetails_Request) GetLanguage() string { + if m != nil && m.Language != nil { + return *m.Language + } + return "" +} + +type CGameNotifications_GetSessionDetails_Request_RequestedSession struct { + Sessionid *uint64 `protobuf:"varint,1,opt,name=sessionid" json:"sessionid,omitempty"` + IncludeAuthUserMessage *bool `protobuf:"varint,3,opt,name=include_auth_user_message" json:"include_auth_user_message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) Reset() { + *m = CGameNotifications_GetSessionDetails_Request_RequestedSession{} +} +func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_GetSessionDetails_Request_RequestedSession) ProtoMessage() {} +func (*CGameNotifications_GetSessionDetails_Request_RequestedSession) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{12, 0} +} + +func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +func (m *CGameNotifications_GetSessionDetails_Request_RequestedSession) GetIncludeAuthUserMessage() bool { + if m != nil && m.IncludeAuthUserMessage != nil { + return *m.IncludeAuthUserMessage + } + return false +} + +type CGameNotifications_GetSessionDetails_Response struct { + Sessions []*CGameNotifications_Session `protobuf:"bytes,1,rep,name=sessions" json:"sessions,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_GetSessionDetails_Response) Reset() { + *m = CGameNotifications_GetSessionDetails_Response{} +} +func (m *CGameNotifications_GetSessionDetails_Response) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_GetSessionDetails_Response) ProtoMessage() {} +func (*CGameNotifications_GetSessionDetails_Response) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{13} +} + +func (m *CGameNotifications_GetSessionDetails_Response) GetSessions() []*CGameNotifications_Session { + if m != nil { + return m.Sessions + } + return nil +} + +type GameNotificationSettings struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + AllowNotifications *bool `protobuf:"varint,2,opt,name=allow_notifications" json:"allow_notifications,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GameNotificationSettings) Reset() { *m = GameNotificationSettings{} } +func (m *GameNotificationSettings) String() string { return proto.CompactTextString(m) } +func (*GameNotificationSettings) ProtoMessage() {} +func (*GameNotificationSettings) Descriptor() ([]byte, []int) { return gamenotifications_fileDescriptor0, []int{14} } + +func (m *GameNotificationSettings) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *GameNotificationSettings) GetAllowNotifications() bool { + if m != nil && m.AllowNotifications != nil { + return *m.AllowNotifications + } + return false +} + +type CGameNotifications_UpdateNotificationSettings_Request struct { + GameNotificationSettings []*GameNotificationSettings `protobuf:"bytes,1,rep,name=game_notification_settings" json:"game_notification_settings,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_UpdateNotificationSettings_Request) Reset() { + *m = CGameNotifications_UpdateNotificationSettings_Request{} +} +func (m *CGameNotifications_UpdateNotificationSettings_Request) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_UpdateNotificationSettings_Request) ProtoMessage() {} +func (*CGameNotifications_UpdateNotificationSettings_Request) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{15} +} + +func (m *CGameNotifications_UpdateNotificationSettings_Request) GetGameNotificationSettings() []*GameNotificationSettings { + if m != nil { + return m.GameNotificationSettings + } + return nil +} + +type CGameNotifications_UpdateNotificationSettings_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_UpdateNotificationSettings_Response) Reset() { + *m = CGameNotifications_UpdateNotificationSettings_Response{} +} +func (m *CGameNotifications_UpdateNotificationSettings_Response) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_UpdateNotificationSettings_Response) ProtoMessage() {} +func (*CGameNotifications_UpdateNotificationSettings_Response) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{16} +} + +type CGameNotifications_OnNotificationsRequested_Notification struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_OnNotificationsRequested_Notification) Reset() { + *m = CGameNotifications_OnNotificationsRequested_Notification{} +} +func (m *CGameNotifications_OnNotificationsRequested_Notification) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_OnNotificationsRequested_Notification) ProtoMessage() {} +func (*CGameNotifications_OnNotificationsRequested_Notification) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{17} +} + +func (m *CGameNotifications_OnNotificationsRequested_Notification) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CGameNotifications_OnNotificationsRequested_Notification) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CGameNotifications_OnUserStatusChanged_Notification struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Sessionid *uint64 `protobuf:"varint,2,opt,name=sessionid" json:"sessionid,omitempty"` + Appid *uint32 `protobuf:"varint,3,opt,name=appid" json:"appid,omitempty"` + Status *CGameNotifications_UserStatus `protobuf:"bytes,4,opt,name=status" json:"status,omitempty"` + Removed *bool `protobuf:"varint,5,opt,name=removed" json:"removed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CGameNotifications_OnUserStatusChanged_Notification) Reset() { + *m = CGameNotifications_OnUserStatusChanged_Notification{} +} +func (m *CGameNotifications_OnUserStatusChanged_Notification) String() string { + return proto.CompactTextString(m) +} +func (*CGameNotifications_OnUserStatusChanged_Notification) ProtoMessage() {} +func (*CGameNotifications_OnUserStatusChanged_Notification) Descriptor() ([]byte, []int) { + return gamenotifications_fileDescriptor0, []int{18} +} + +func (m *CGameNotifications_OnUserStatusChanged_Notification) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CGameNotifications_OnUserStatusChanged_Notification) GetSessionid() uint64 { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return 0 +} + +func (m *CGameNotifications_OnUserStatusChanged_Notification) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CGameNotifications_OnUserStatusChanged_Notification) GetStatus() *CGameNotifications_UserStatus { + if m != nil { + return m.Status + } + return nil +} + +func (m *CGameNotifications_OnUserStatusChanged_Notification) GetRemoved() bool { + if m != nil && m.Removed != nil { + return *m.Removed + } + return false +} + +func init() { + proto.RegisterType((*CGameNotifications_Variable)(nil), "CGameNotifications_Variable") + proto.RegisterType((*CGameNotifications_LocalizedText)(nil), "CGameNotifications_LocalizedText") + proto.RegisterType((*CGameNotifications_UserStatus)(nil), "CGameNotifications_UserStatus") + proto.RegisterType((*CGameNotifications_CreateSession_Request)(nil), "CGameNotifications_CreateSession_Request") + proto.RegisterType((*CGameNotifications_CreateSession_Response)(nil), "CGameNotifications_CreateSession_Response") + proto.RegisterType((*CGameNotifications_DeleteSession_Request)(nil), "CGameNotifications_DeleteSession_Request") + proto.RegisterType((*CGameNotifications_DeleteSession_Response)(nil), "CGameNotifications_DeleteSession_Response") + proto.RegisterType((*CGameNotifications_UpdateSession_Request)(nil), "CGameNotifications_UpdateSession_Request") + proto.RegisterType((*CGameNotifications_UpdateSession_Response)(nil), "CGameNotifications_UpdateSession_Response") + proto.RegisterType((*CGameNotifications_EnumerateSessions_Request)(nil), "CGameNotifications_EnumerateSessions_Request") + proto.RegisterType((*CGameNotifications_Session)(nil), "CGameNotifications_Session") + proto.RegisterType((*CGameNotifications_EnumerateSessions_Response)(nil), "CGameNotifications_EnumerateSessions_Response") + proto.RegisterType((*CGameNotifications_GetSessionDetails_Request)(nil), "CGameNotifications_GetSessionDetails_Request") + proto.RegisterType((*CGameNotifications_GetSessionDetails_Request_RequestedSession)(nil), "CGameNotifications_GetSessionDetails_Request.RequestedSession") + proto.RegisterType((*CGameNotifications_GetSessionDetails_Response)(nil), "CGameNotifications_GetSessionDetails_Response") + proto.RegisterType((*GameNotificationSettings)(nil), "GameNotificationSettings") + proto.RegisterType((*CGameNotifications_UpdateNotificationSettings_Request)(nil), "CGameNotifications_UpdateNotificationSettings_Request") + proto.RegisterType((*CGameNotifications_UpdateNotificationSettings_Response)(nil), "CGameNotifications_UpdateNotificationSettings_Response") + proto.RegisterType((*CGameNotifications_OnNotificationsRequested_Notification)(nil), "CGameNotifications_OnNotificationsRequested_Notification") + proto.RegisterType((*CGameNotifications_OnUserStatusChanged_Notification)(nil), "CGameNotifications_OnUserStatusChanged_Notification") +} + +var gamenotifications_fileDescriptor0 = []byte{ + // 2245 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x8f, 0x1c, 0x47, + 0x15, 0x57, 0xef, 0xec, 0x7a, 0xd7, 0x65, 0x2c, 0x91, 0x0e, 0x12, 0x93, 0xb1, 0xe3, 0xb4, 0x3b, + 0x38, 0xde, 0x8d, 0x77, 0xcb, 0x78, 0x43, 0xfc, 0x01, 0x24, 0xc2, 0xbd, 0x8e, 0x4c, 0x24, 0xb3, + 0x49, 0xbc, 0x9b, 0x60, 0x21, 0xc4, 0xa8, 0xa6, 0xbb, 0x66, 0xa7, 0xb3, 0x3d, 0xdd, 0x43, 0x57, + 0xf5, 0x6e, 0x36, 0x07, 0x82, 0xcc, 0xd7, 0x09, 0x82, 0x48, 0x22, 0x40, 0x48, 0x91, 0x90, 0x50, + 0xc4, 0x81, 0x0b, 0x87, 0x1c, 0x41, 0x48, 0x91, 0x38, 0x72, 0xcc, 0x15, 0xce, 0xfc, 0x15, 0xbc, + 0xfa, 0xec, 0xee, 0x99, 0x1e, 0xef, 0xcc, 0x22, 0x11, 0x71, 0xb1, 0x3c, 0x5d, 0xf5, 0xde, 0xfb, + 0xd5, 0x7b, 0xbf, 0xf7, 0x51, 0xb5, 0xe8, 0x1a, 0xe3, 0x94, 0x0c, 0x87, 0x94, 0x31, 0xb2, 0x47, + 0x59, 0x77, 0x8f, 0x0c, 0x69, 0x9a, 0xf1, 0xb8, 0x1f, 0x87, 0x84, 0xc7, 0x59, 0xca, 0xb0, 0x5c, + 0x0f, 0x93, 0x98, 0xa6, 0x1c, 0x8f, 0xf2, 0x8c, 0x67, 0x9d, 0xf5, 0xba, 0x48, 0x91, 0xc2, 0x6e, + 0x1a, 0x75, 0x7b, 0x84, 0xd1, 0xc9, 0xdd, 0xfe, 0xbf, 0x16, 0xd0, 0xb9, 0xad, 0xbb, 0xa0, 0x76, + 0xbb, 0xaa, 0xb6, 0xfb, 0x06, 0xc9, 0x63, 0xd2, 0x4b, 0xa8, 0xfb, 0x91, 0x83, 0x5a, 0xfb, 0xf4, + 0xa8, 0xed, 0x78, 0xce, 0xea, 0xe9, 0xe0, 0x37, 0xce, 0xc3, 0x8f, 0xdb, 0xef, 0x39, 0xbb, 0x03, + 0xea, 0xa5, 0x20, 0xe3, 0x65, 0x7d, 0x8f, 0xc3, 0xff, 0x0f, 0xf4, 0x6e, 0x2f, 0x4e, 0xe5, 0xef, + 0x24, 0x0b, 0x49, 0x12, 0xbf, 0x4d, 0x23, 0x8f, 0xd3, 0xb7, 0xb8, 0xb7, 0xb1, 0xe1, 0x91, 0xf4, + 0xe8, 0x70, 0x40, 0x73, 0x0a, 0xcb, 0x84, 0x7b, 0x97, 0x8c, 0x80, 0x50, 0x72, 0xc9, 0x8b, 0x99, + 0xd7, 0xcf, 0x8a, 0x34, 0xf2, 0x0e, 0x63, 0x3e, 0xd0, 0x2a, 0xa4, 0x60, 0xcc, 0xe1, 0x53, 0x92, + 0x78, 0x3d, 0xea, 0xb1, 0xa2, 0xc7, 0x78, 0xcc, 0x8b, 0x88, 0xaa, 0x6d, 0x72, 0xd3, 0x5e, 0x7c, + 0x40, 0x53, 0xb0, 0x9e, 0x14, 0xd4, 0xfd, 0xb5, 0x83, 0x96, 0xe4, 0xff, 0xda, 0x0b, 0x12, 0xea, + 0xcf, 0x04, 0xd4, 0x87, 0x12, 0xaa, 0xfc, 0x3c, 0x81, 0x95, 0x67, 0x56, 0x29, 0x9f, 0x86, 0x1c, + 0xbe, 0x8e, 0x12, 0x12, 0x5a, 0x61, 0x63, 0x50, 0xa9, 0xc0, 0x9e, 0xb7, 0x45, 0x52, 0x40, 0xc9, + 0x68, 0xd2, 0x17, 0x20, 0x89, 0x91, 0x97, 0x5e, 0x04, 0x0b, 0xfb, 0x34, 0xc5, 0xfe, 0x4f, 0x5a, + 0xc8, 0x6b, 0x70, 0xf1, 0x3d, 0x63, 0x6a, 0x17, 0x2c, 0xb9, 0xdf, 0x44, 0x4b, 0x72, 0xbb, 0x76, + 0xf4, 0x2d, 0x00, 0xff, 0xfc, 0xed, 0x06, 0x75, 0xca, 0x81, 0x43, 0x32, 0x62, 0xe2, 0x00, 0x02, + 0x53, 0x44, 0x59, 0x9c, 0x03, 0x60, 0xc6, 0xf3, 0x38, 0xdd, 0xc3, 0xee, 0xcf, 0x1d, 0x74, 0xda, + 0x20, 0x64, 0xe0, 0x8c, 0xd6, 0xea, 0x99, 0xcd, 0xf3, 0xf8, 0x11, 0x31, 0x0e, 0xbe, 0x0b, 0xc6, + 0x1e, 0x80, 0xb1, 0x98, 0x71, 0x71, 0x50, 0x2b, 0xac, 0x1c, 0xc7, 0x26, 0x3d, 0x05, 0xd1, 0xac, + 0xec, 0x52, 0xb1, 0x9b, 0x70, 0xa0, 0xc1, 0xf3, 0x53, 0x07, 0x9d, 0xcd, 0x69, 0x1a, 0x41, 0xf4, + 0xa3, 0xae, 0xf0, 0x6a, 0xbb, 0x25, 0x8f, 0x98, 0x81, 0xd5, 0x7d, 0x71, 0x76, 0xcf, 0xac, 0x1a, + 0x1d, 0x39, 0xfd, 0x3e, 0x98, 0xe5, 0xf0, 0x21, 0x21, 0xe9, 0x5e, 0x01, 0x34, 0x5e, 0xf7, 0xc2, + 0x6c, 0x38, 0x4a, 0x28, 0x98, 0x97, 0xc1, 0xb7, 0x41, 0xb4, 0xb8, 0xc4, 0x89, 0xd6, 0xbd, 0xb8, + 0x2f, 0x62, 0xa0, 0x85, 0xbc, 0x43, 0xc2, 0x3c, 0x36, 0xa2, 0xa1, 0x4c, 0x00, 0xec, 0x7f, 0xb0, + 0x88, 0x9e, 0x6c, 0x70, 0xc3, 0xeb, 0x8c, 0xe6, 0x3b, 0x9c, 0xf0, 0x82, 0xb9, 0xd7, 0xd0, 0xb2, + 0xcc, 0x90, 0x38, 0x92, 0x61, 0x38, 0x15, 0x78, 0x80, 0xf1, 0xbc, 0xa0, 0x90, 0x56, 0x13, 0x7a, + 0x05, 0xec, 0xbe, 0x0c, 0x6a, 0xd5, 0x36, 0xec, 0xfe, 0x01, 0x68, 0xc7, 0x40, 0xda, 0xd0, 0xee, + 0x7d, 0x41, 0xbb, 0x77, 0x25, 0xed, 0xec, 0x56, 0x58, 0x05, 0xaa, 0xe4, 0x94, 0x44, 0x47, 0x22, + 0x17, 0xb8, 0x5e, 0x13, 0xbc, 0x57, 0x1f, 0xc1, 0xc1, 0x40, 0xb3, 0x23, 0xd8, 0x74, 0x48, 0x62, + 0x0e, 0x5e, 0x13, 0xdb, 0x84, 0x0a, 0x91, 0xef, 0x62, 0x9b, 0xf9, 0x9c, 0x09, 0xdf, 0x7b, 0x24, + 0x94, 0x7c, 0xe8, 0xe7, 0xd9, 0xd0, 0x2a, 0xc3, 0xd6, 0x43, 0xd1, 0xba, 0xa2, 0xaa, 0x16, 0xcd, + 0x0e, 0x60, 0xd1, 0xfd, 0x31, 0xc0, 0x04, 0x3f, 0x25, 0x54, 0x3a, 0xff, 0xcc, 0xe6, 0x45, 0x7c, + 0x1c, 0x23, 0x83, 0xfb, 0x70, 0x90, 0xed, 0x5d, 0x21, 0x63, 0xd8, 0xcf, 0xa0, 0xa6, 0x28, 0x22, + 0x7a, 0x51, 0xcc, 0x04, 0x62, 0xc5, 0x41, 0xb0, 0xa2, 0xce, 0x23, 0xc3, 0x17, 0xe7, 0x96, 0x49, + 0x02, 0xe8, 0x81, 0x95, 0x63, 0xd8, 0xfd, 0x95, 0x83, 0x96, 0x75, 0x65, 0x6a, 0x2f, 0xce, 0x0a, + 0xe4, 0x7b, 0x00, 0xe4, 0x3b, 0x3b, 0x45, 0x8f, 0xcf, 0x83, 0x45, 0xfe, 0x53, 0xd6, 0x93, 0x47, + 0x80, 0xf2, 0xdf, 0x5b, 0x42, 0xab, 0x0d, 0x20, 0xb6, 0x20, 0x36, 0x9c, 0xee, 0xa8, 0x6d, 0xdd, + 0xfb, 0x8a, 0x93, 0xee, 0x0d, 0xb4, 0x44, 0x46, 0x23, 0x4d, 0x90, 0xb3, 0xc1, 0x2a, 0x60, 0xfb, + 0x92, 0x88, 0x94, 0xfc, 0x28, 0x20, 0x84, 0x52, 0xac, 0x86, 0xb1, 0x9f, 0x41, 0x04, 0xde, 0x41, + 0xcb, 0x61, 0x96, 0x4a, 0xfe, 0x0b, 0xa6, 0x2c, 0x06, 0x29, 0x88, 0xbe, 0x29, 0xcc, 0x6e, 0x58, + 0x8e, 0x7a, 0x7a, 0x87, 0xae, 0x58, 0x36, 0x8c, 0x21, 0x04, 0x1d, 0x0e, 0x24, 0xf5, 0x13, 0xc6, + 0xb2, 0x30, 0x1e, 0x37, 0x21, 0xb3, 0x82, 0x65, 0xa2, 0x24, 0xf7, 0xde, 0xa4, 0x21, 0x17, 0x4c, + 0x51, 0xc7, 0xee, 0x91, 0x10, 0xca, 0x06, 0x30, 0xf5, 0x47, 0xf3, 0x53, 0xe0, 0x35, 0x80, 0xf8, + 0x2d, 0x71, 0xba, 0x69, 0xae, 0x87, 0x9a, 0xa7, 0xbd, 0x4f, 0x6d, 0xf5, 0xa6, 0x24, 0x1c, 0x18, + 0xee, 0x1b, 0x9f, 0x97, 0x0c, 0x20, 0x68, 0x49, 0xac, 0x31, 0x08, 0xbf, 0x28, 0x4c, 0x17, 0xf0, + 0x23, 0x33, 0x32, 0xd8, 0x04, 0x04, 0x58, 0x20, 0x88, 0x53, 0xc8, 0x00, 0x92, 0xa8, 0x6c, 0x92, + 0x61, 0x84, 0xbe, 0x20, 0x35, 0x99, 0xaa, 0xa1, 0x6d, 0x60, 0xf7, 0x13, 0xa7, 0x4c, 0xe3, 0x25, + 0x99, 0xc6, 0x7f, 0x16, 0x49, 0xf9, 0x27, 0x67, 0xf5, 0x95, 0x91, 0x30, 0x40, 0x92, 0x35, 0x93, + 0xbf, 0xe2, 0x0c, 0x43, 0xb2, 0x4f, 0xab, 0x65, 0x47, 0xb8, 0xae, 0x47, 0x07, 0x04, 0x4a, 0x3a, + 0x98, 0x81, 0x44, 0x84, 0xa2, 0x62, 0x23, 0xb4, 0x5e, 0x66, 0xef, 0xb0, 0x80, 0xbd, 0x3d, 0x3a, + 0x66, 0x1e, 0xf2, 0x33, 0xaa, 0x60, 0xeb, 0x51, 0x91, 0xb6, 0x24, 0x8a, 0x54, 0xf0, 0xaa, 0x1b, + 0x8d, 0x7c, 0x3f, 0x87, 0x76, 0x1c, 0xb1, 0xb2, 0xab, 0xc9, 0x74, 0xf6, 0x63, 0xb4, 0x36, 0x03, + 0x29, 0xd9, 0x08, 0xbe, 0x52, 0xf7, 0xeb, 0xe8, 0xb4, 0x56, 0xab, 0x99, 0xb9, 0x18, 0xac, 0xc1, + 0x91, 0x2f, 0xed, 0x96, 0xf6, 0xe0, 0xb0, 0x3a, 0x7e, 0x8a, 0xa1, 0x91, 0x75, 0x98, 0xff, 0xee, + 0x42, 0x63, 0x02, 0xdc, 0xa1, 0xa2, 0x9c, 0x8c, 0x27, 0xc0, 0xd5, 0x49, 0x53, 0xe7, 0xc1, 0x54, + 0xbb, 0x6e, 0x4a, 0xa4, 0xa5, 0x14, 0xc7, 0xee, 0x75, 0x93, 0x31, 0x0b, 0x32, 0x63, 0x2e, 0xc3, + 0xe6, 0xa7, 0xcb, 0x8c, 0x69, 0x48, 0x67, 0x2d, 0xf7, 0x76, 0x19, 0xc5, 0x96, 0x8c, 0x62, 0x0c, + 0x92, 0xf4, 0x7f, 0x11, 0x43, 0xec, 0x5f, 0x69, 0x74, 0xfe, 0xb8, 0x43, 0x94, 0xf3, 0xfd, 0xbf, + 0x34, 0xd7, 0x8f, 0xd7, 0x47, 0x11, 0xf9, 0x2f, 0xdc, 0x57, 0x48, 0xf1, 0xf9, 0xdd, 0x67, 0xe4, + 0x7e, 0x39, 0x7f, 0xba, 0xcb, 0x42, 0x5b, 0x71, 0xb0, 0x1c, 0xf3, 0xe8, 0x61, 0x63, 0xf6, 0x43, + 0xaf, 0x7a, 0xb9, 0xef, 0xc1, 0x2c, 0x3a, 0xee, 0x57, 0xb5, 0x59, 0x8e, 0x6d, 0x62, 0x15, 0x9c, + 0x1b, 0x0e, 0xa0, 0x21, 0x43, 0x03, 0x76, 0xff, 0xe1, 0xcc, 0x97, 0xfc, 0x1f, 0x8a, 0xb4, 0xfd, + 0x6d, 0x35, 0x6d, 0xcb, 0x21, 0x45, 0xa5, 0xd7, 0xe1, 0x20, 0x63, 0x54, 0xd7, 0x04, 0x33, 0x29, + 0x2a, 0x07, 0x48, 0x1f, 0xe6, 0xb4, 0x9f, 0x88, 0x62, 0x58, 0x8e, 0x6e, 0xba, 0x19, 0xbf, 0xdc, + 0xb7, 0x1c, 0x60, 0x1e, 0x81, 0xb1, 0x54, 0x40, 0x25, 0x89, 0xea, 0xc6, 0x75, 0x32, 0xc8, 0x53, + 0x1d, 0x59, 0xed, 0x36, 0x95, 0x63, 0x5e, 0xaf, 0x34, 0xa7, 0xfe, 0x6f, 0x2b, 0x4d, 0x33, 0xd9, + 0xc7, 0xe9, 0xab, 0xc9, 0xfe, 0xfb, 0x45, 0xb4, 0xde, 0xb0, 0xfb, 0xa5, 0xb4, 0x18, 0xd2, 0xbc, + 0x14, 0x60, 0x96, 0xf0, 0x3f, 0xa8, 0x37, 0x4c, 0x35, 0xf5, 0x8d, 0x93, 0xdd, 0x38, 0x24, 0xa2, + 0x9c, 0xc4, 0x09, 0x93, 0x1d, 0xd3, 0x33, 0x3e, 0xc4, 0x0d, 0x4c, 0x13, 0xe7, 0xe6, 0x95, 0x19, + 0x4b, 0x5b, 0xb5, 0x61, 0xca, 0x29, 0x2f, 0xf2, 0x54, 0x90, 0xee, 0x17, 0x0e, 0x7a, 0x22, 0x4e, + 0xc3, 0x04, 0x6e, 0x0e, 0x5d, 0x90, 0xea, 0x0a, 0x89, 0xae, 0xb9, 0x1d, 0xc9, 0xdc, 0x58, 0x09, + 0xf6, 0x01, 0xd4, 0x5e, 0x25, 0x66, 0x41, 0x96, 0x25, 0x14, 0x7a, 0x2e, 0xc0, 0xa1, 0xf9, 0x10, + 0x5a, 0x0f, 0x78, 0x16, 0xae, 0x2f, 0x60, 0x30, 0x97, 0x56, 0xb5, 0xb8, 0x80, 0x59, 0x89, 0x00, + 0x1b, 0x64, 0x45, 0x12, 0xa9, 0x40, 0x49, 0x7b, 0x11, 0xf6, 0xee, 0xd0, 0x3e, 0x29, 0x12, 0x2e, + 0x67, 0xe8, 0x3e, 0x49, 0xe0, 0x0a, 0xe6, 0xfe, 0xae, 0x0a, 0xa8, 0xe0, 0x83, 0x1a, 0x22, 0x39, + 0x15, 0xad, 0x04, 0x6f, 0x01, 0x20, 0x7e, 0x42, 0x40, 0xe2, 0xb7, 0xd0, 0x0b, 0x77, 0x3c, 0x11, + 0x1e, 0xa0, 0x83, 0x24, 0xd1, 0x8c, 0xe8, 0x02, 0xb4, 0x62, 0xe6, 0x67, 0xd9, 0x3c, 0x4f, 0x07, + 0x5f, 0x06, 0x2c, 0xeb, 0x15, 0x2c, 0xf7, 0xcc, 0x78, 0x0d, 0x42, 0x66, 0xda, 0xaf, 0x5c, 0xd9, + 0xa0, 0x7a, 0x7e, 0xb2, 0x88, 0x3a, 0x0d, 0x1c, 0xd1, 0xd4, 0x80, 0x8a, 0x36, 0x51, 0x02, 0x9f, + 0x06, 0x1b, 0x4f, 0xd5, 0x59, 0xa1, 0x8e, 0x12, 0xb3, 0xb2, 0xaf, 0x6f, 0x54, 0x2b, 0xe1, 0x62, + 0x70, 0x01, 0x64, 0x3a, 0x65, 0x25, 0x34, 0x47, 0xb7, 0xdb, 0x2b, 0x03, 0x57, 0xeb, 0x33, 0x19, + 0xb8, 0x1e, 0x98, 0x02, 0x3c, 0xf3, 0xa4, 0xfb, 0x0c, 0x20, 0xf4, 0xc5, 0x91, 0xc2, 0x22, 0x87, + 0x4b, 0x11, 0xd7, 0xc5, 0x74, 0xe2, 0x68, 0x5f, 0x43, 0x9f, 0xe3, 0xf1, 0x90, 0x76, 0x75, 0x27, + 0x97, 0x81, 0x3a, 0x1b, 0x5c, 0x02, 0xe9, 0x8b, 0x6a, 0x5a, 0x1b, 0x8e, 0x81, 0x85, 0x8b, 0x90, + 0xde, 0x8b, 0xdd, 0x6f, 0x68, 0x61, 0x5d, 0x27, 0x65, 0xe1, 0x3a, 0x1b, 0x3c, 0x0b, 0xc2, 0xcf, + 0x08, 0xe1, 0x84, 0x30, 0xde, 0xac, 0x41, 0x0b, 0x60, 0x37, 0x42, 0x67, 0x24, 0x67, 0x99, 0x2c, + 0xd3, 0xed, 0xe5, 0x99, 0x8a, 0xf9, 0x55, 0x30, 0x70, 0x45, 0x86, 0x58, 0xfe, 0x36, 0x23, 0x5c, + 0x59, 0x86, 0xc7, 0x7b, 0xf0, 0x43, 0x07, 0x6d, 0xcc, 0x58, 0x69, 0xf4, 0x14, 0xf4, 0x1a, 0x5a, + 0x31, 0x85, 0x00, 0x78, 0x25, 0x40, 0x9d, 0xc3, 0xd3, 0x79, 0x18, 0xf8, 0x80, 0xe8, 0x42, 0xd9, + 0x51, 0x1a, 0xca, 0x09, 0xf6, 0x3f, 0x6d, 0x35, 0x96, 0xbb, 0xbb, 0x94, 0x6b, 0x2d, 0x77, 0x54, + 0xc5, 0xb2, 0xe5, 0xee, 0xd5, 0x09, 0x0c, 0x2f, 0xe2, 0x79, 0x14, 0xe0, 0xfb, 0xe6, 0xf2, 0x6b, + 0xd2, 0x05, 0xd7, 0x07, 0x80, 0xa7, 0x00, 0xf5, 0xb9, 0xa9, 0xb4, 0x87, 0x09, 0xfb, 0x46, 0x25, + 0x83, 0xd5, 0x4d, 0x5b, 0x12, 0xe3, 0xd8, 0xb4, 0xed, 0xfc, 0xdb, 0x41, 0x9f, 0x9f, 0xb0, 0x7e, + 0x73, 0x32, 0x59, 0x2d, 0xcf, 0x6a, 0x25, 0x7c, 0x8f, 0xd6, 0xcb, 0xf7, 0x31, 0x75, 0xae, 0xf5, + 0xd9, 0xd6, 0x39, 0xff, 0x9d, 0x46, 0x72, 0x35, 0x85, 0x45, 0x93, 0x6b, 0x7b, 0x3e, 0x72, 0xd9, + 0x30, 0x19, 0x9f, 0x8c, 0x8d, 0x4f, 0xfe, 0x1f, 0x1d, 0xd4, 0x1e, 0x17, 0xdf, 0xa1, 0x5c, 0x5c, + 0xf3, 0xd9, 0xc9, 0x6f, 0x99, 0x3b, 0xe8, 0x71, 0xc8, 0xaa, 0xec, 0xb0, 0x5b, 0x7b, 0x25, 0x94, + 0xd4, 0x59, 0x09, 0xae, 0x83, 0x9a, 0xcd, 0x6f, 0x57, 0xdc, 0x29, 0x1d, 0x26, 0xf7, 0x33, 0xaf, + 0x2a, 0x50, 0x16, 0x5f, 0x30, 0x88, 0xfd, 0x03, 0xf4, 0xfc, 0xd4, 0x01, 0xa1, 0x09, 0xbe, 0x4d, + 0x86, 0x17, 0x50, 0x47, 0x94, 0xd3, 0x1a, 0x98, 0x2e, 0xd3, 0xbb, 0xb4, 0x17, 0x9f, 0xc0, 0xd3, + 0xbc, 0xe0, 0xdf, 0x44, 0xd7, 0xe7, 0xb5, 0xab, 0xa7, 0x94, 0xbf, 0x3b, 0xe8, 0x66, 0x83, 0xe8, + 0x2b, 0x69, 0xed, 0xb7, 0x25, 0x7b, 0xb7, 0xfa, 0x19, 0x22, 0x3d, 0xf6, 0x0a, 0xf4, 0x02, 0xf8, + 0xed, 0x96, 0x99, 0xe3, 0x2a, 0x95, 0x42, 0x8c, 0x9f, 0x35, 0xbf, 0xc1, 0xfc, 0x21, 0xde, 0x38, + 0xcb, 0xf7, 0x2b, 0x19, 0x93, 0xaf, 0xd6, 0x13, 0xf8, 0x0a, 0x68, 0xbb, 0x5c, 0x09, 0xa6, 0x78, + 0xcf, 0x2b, 0x25, 0xea, 0xaf, 0xbb, 0xfe, 0x5f, 0x5b, 0xe8, 0xb9, 0xc6, 0x83, 0x94, 0x95, 0x75, + 0x4b, 0x8d, 0xd7, 0xf5, 0x33, 0xbc, 0x38, 0x7e, 0x86, 0x0d, 0xb0, 0xba, 0x36, 0xe5, 0x0c, 0xcc, + 0x16, 0x65, 0x3b, 0xaa, 0x3f, 0xa8, 0xa6, 0xbd, 0xea, 0xb7, 0x2f, 0x81, 0x86, 0xdb, 0x8d, 0x17, + 0x4a, 0xdb, 0x24, 0xf4, 0x0b, 0x6f, 0xed, 0xe9, 0xab, 0x60, 0xaa, 0xfd, 0x18, 0xcd, 0xf7, 0x8c, + 0x37, 0x5a, 0xd2, 0x1b, 0xd2, 0xb7, 0x53, 0xef, 0x33, 0xd3, 0x34, 0x5a, 0x6d, 0x6f, 0xa0, 0x53, + 0xba, 0x0b, 0xa9, 0x26, 0x7b, 0x5c, 0x17, 0x92, 0x1d, 0xb6, 0x52, 0x70, 0xb6, 0xe1, 0x7a, 0x53, + 0x36, 0x24, 0x3b, 0x13, 0xbb, 0x77, 0xd1, 0x72, 0x4e, 0x87, 0xd9, 0x81, 0x6e, 0xae, 0x3a, 0x77, + 0x2a, 0x82, 0x42, 0xa7, 0x37, 0x20, 0x62, 0xee, 0x86, 0x6b, 0x85, 0xde, 0x5b, 0x3e, 0xc9, 0x99, + 0x34, 0xdf, 0xfc, 0x68, 0x05, 0x3d, 0x36, 0x81, 0x48, 0xbc, 0xd1, 0x3e, 0x26, 0x34, 0xd4, 0xae, + 0xf3, 0xee, 0x1a, 0x9e, 0xf5, 0x19, 0xaa, 0xf3, 0x2c, 0x9e, 0xf9, 0x71, 0xc0, 0xbf, 0x08, 0xd0, + 0x9f, 0x54, 0x6b, 0x4c, 0x3e, 0x1f, 0xb2, 0xa3, 0x34, 0x54, 0x73, 0x8e, 0x86, 0x69, 0xf1, 0xd4, + 0x6e, 0xb8, 0xcd, 0x78, 0x1a, 0x5f, 0x05, 0x9a, 0xf1, 0x4c, 0xb9, 0x2f, 0x4b, 0x3c, 0x6a, 0xed, + 0x38, 0x3c, 0xb5, 0x4b, 0x48, 0x33, 0x9e, 0xc6, 0x6b, 0x76, 0x33, 0x9e, 0x29, 0x57, 0x1a, 0x89, + 0x47, 0xad, 0x4d, 0xc3, 0xf3, 0x3e, 0xe0, 0x99, 0x18, 0x3c, 0xdc, 0x0d, 0x3c, 0xcf, 0x4d, 0xa8, + 0x83, 0xf1, 0x5c, 0xe3, 0x8c, 0x2f, 0x1f, 0x9f, 0xed, 0x3a, 0x40, 0x1b, 0x1f, 0x4f, 0xdc, 0x0f, + 0x01, 0xd6, 0x44, 0xcb, 0x6a, 0x86, 0x35, 0x75, 0xe0, 0x68, 0x86, 0x35, 0xbd, 0x11, 0xfa, 0x72, + 0x52, 0x84, 0x75, 0xfd, 0xc7, 0x07, 0xdb, 0xf1, 0x01, 0x9f, 0x7d, 0x25, 0x37, 0x7e, 0xfb, 0xd4, + 0x41, 0x9d, 0xe9, 0xf5, 0xda, 0xbd, 0x8e, 0x4f, 0xd4, 0x57, 0x3a, 0x37, 0xf0, 0x09, 0xfb, 0xc2, + 0x5d, 0xc0, 0xbe, 0x65, 0x42, 0x6d, 0x06, 0x0b, 0x52, 0xeb, 0x83, 0x32, 0xee, 0xf5, 0xa2, 0x3e, + 0x76, 0x38, 0xa8, 0x54, 0x9d, 0x57, 0x41, 0xd1, 0xbd, 0xdb, 0x70, 0xce, 0xfc, 0x20, 0x0e, 0xd5, + 0x3c, 0xd2, 0x2f, 0xd2, 0x50, 0xed, 0xcf, 0x69, 0x62, 0x5e, 0x20, 0xe4, 0x90, 0x22, 0xf8, 0x94, + 0x67, 0x69, 0x56, 0x34, 0x68, 0x97, 0x2a, 0xa0, 0xe2, 0x6c, 0xfe, 0x73, 0x01, 0x7d, 0x71, 0xe2, + 0x50, 0x5b, 0xf2, 0x4f, 0x75, 0xee, 0x07, 0x30, 0x2b, 0x4c, 0xeb, 0x5d, 0xee, 0x2d, 0x7c, 0xd2, + 0x4e, 0xd7, 0x39, 0x83, 0xb7, 0x33, 0xeb, 0x9b, 0x6b, 0x70, 0xa4, 0x0d, 0xbd, 0x91, 0xa9, 0xb6, + 0x64, 0x9b, 0x44, 0x36, 0x12, 0x23, 0x22, 0x1f, 0xeb, 0x76, 0x22, 0x4d, 0x1f, 0x6f, 0x68, 0x45, + 0xee, 0x57, 0xf0, 0x09, 0x7a, 0x56, 0x1d, 0xcd, 0x73, 0x80, 0xe6, 0x6a, 0x75, 0xb9, 0x8e, 0xa8, + 0x6c, 0x05, 0x83, 0xb2, 0xb9, 0x74, 0xc4, 0x4b, 0xda, 0x17, 0x94, 0xcf, 0xea, 0x48, 0xff, 0xf6, + 0x71, 0x7b, 0x21, 0x68, 0xfd, 0xd0, 0x71, 0xfe, 0x13, 0x00, 0x00, 0xff, 0xff, 0x0c, 0x81, 0x5e, + 0xd6, 0x51, 0x1d, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/offline.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/offline.pb.go new file mode 100644 index 00000000..91554fcb --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/offline.pb.go @@ -0,0 +1,163 @@ +// Code generated by protoc-gen-go. +// source: steammessages_offline.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type COffline_GetOfflineLogonTicket_Request struct { + Priority *uint32 `protobuf:"varint,1,opt,name=priority" json:"priority,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *COffline_GetOfflineLogonTicket_Request) Reset() { + *m = COffline_GetOfflineLogonTicket_Request{} +} +func (m *COffline_GetOfflineLogonTicket_Request) String() string { return proto.CompactTextString(m) } +func (*COffline_GetOfflineLogonTicket_Request) ProtoMessage() {} +func (*COffline_GetOfflineLogonTicket_Request) Descriptor() ([]byte, []int) { + return offline_fileDescriptor0, []int{0} +} + +func (m *COffline_GetOfflineLogonTicket_Request) GetPriority() uint32 { + if m != nil && m.Priority != nil { + return *m.Priority + } + return 0 +} + +type COffline_GetOfflineLogonTicket_Response struct { + SerializedTicket []byte `protobuf:"bytes,1,opt,name=serialized_ticket" json:"serialized_ticket,omitempty"` + Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *COffline_GetOfflineLogonTicket_Response) Reset() { + *m = COffline_GetOfflineLogonTicket_Response{} +} +func (m *COffline_GetOfflineLogonTicket_Response) String() string { return proto.CompactTextString(m) } +func (*COffline_GetOfflineLogonTicket_Response) ProtoMessage() {} +func (*COffline_GetOfflineLogonTicket_Response) Descriptor() ([]byte, []int) { + return offline_fileDescriptor0, []int{1} +} + +func (m *COffline_GetOfflineLogonTicket_Response) GetSerializedTicket() []byte { + if m != nil { + return m.SerializedTicket + } + return nil +} + +func (m *COffline_GetOfflineLogonTicket_Response) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +type COffline_GetUnsignedOfflineLogonTicket_Request struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *COffline_GetUnsignedOfflineLogonTicket_Request) Reset() { + *m = COffline_GetUnsignedOfflineLogonTicket_Request{} +} +func (m *COffline_GetUnsignedOfflineLogonTicket_Request) String() string { + return proto.CompactTextString(m) +} +func (*COffline_GetUnsignedOfflineLogonTicket_Request) ProtoMessage() {} +func (*COffline_GetUnsignedOfflineLogonTicket_Request) Descriptor() ([]byte, []int) { + return offline_fileDescriptor0, []int{2} +} + +type COffline_OfflineLogonTicket struct { + Accountid *uint32 `protobuf:"varint,1,opt,name=accountid" json:"accountid,omitempty"` + Rtime32CreationTime *uint32 `protobuf:"fixed32,2,opt,name=rtime32_creation_time" json:"rtime32_creation_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *COffline_OfflineLogonTicket) Reset() { *m = COffline_OfflineLogonTicket{} } +func (m *COffline_OfflineLogonTicket) String() string { return proto.CompactTextString(m) } +func (*COffline_OfflineLogonTicket) ProtoMessage() {} +func (*COffline_OfflineLogonTicket) Descriptor() ([]byte, []int) { return offline_fileDescriptor0, []int{3} } + +func (m *COffline_OfflineLogonTicket) GetAccountid() uint32 { + if m != nil && m.Accountid != nil { + return *m.Accountid + } + return 0 +} + +func (m *COffline_OfflineLogonTicket) GetRtime32CreationTime() uint32 { + if m != nil && m.Rtime32CreationTime != nil { + return *m.Rtime32CreationTime + } + return 0 +} + +type COffline_GetUnsignedOfflineLogonTicket_Response struct { + Ticket *COffline_OfflineLogonTicket `protobuf:"bytes,1,opt,name=ticket" json:"ticket,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *COffline_GetUnsignedOfflineLogonTicket_Response) Reset() { + *m = COffline_GetUnsignedOfflineLogonTicket_Response{} +} +func (m *COffline_GetUnsignedOfflineLogonTicket_Response) String() string { + return proto.CompactTextString(m) +} +func (*COffline_GetUnsignedOfflineLogonTicket_Response) ProtoMessage() {} +func (*COffline_GetUnsignedOfflineLogonTicket_Response) Descriptor() ([]byte, []int) { + return offline_fileDescriptor0, []int{4} +} + +func (m *COffline_GetUnsignedOfflineLogonTicket_Response) GetTicket() *COffline_OfflineLogonTicket { + if m != nil { + return m.Ticket + } + return nil +} + +func init() { + proto.RegisterType((*COffline_GetOfflineLogonTicket_Request)(nil), "COffline_GetOfflineLogonTicket_Request") + proto.RegisterType((*COffline_GetOfflineLogonTicket_Response)(nil), "COffline_GetOfflineLogonTicket_Response") + proto.RegisterType((*COffline_GetUnsignedOfflineLogonTicket_Request)(nil), "COffline_GetUnsignedOfflineLogonTicket_Request") + proto.RegisterType((*COffline_OfflineLogonTicket)(nil), "COffline_OfflineLogonTicket") + proto.RegisterType((*COffline_GetUnsignedOfflineLogonTicket_Response)(nil), "COffline_GetUnsignedOfflineLogonTicket_Response") +} + +var offline_fileDescriptor0 = []byte{ + // 377 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x52, 0xcd, 0x4a, 0xf3, 0x40, + 0x14, 0x25, 0x5f, 0xe1, 0xab, 0x8e, 0x0a, 0x76, 0xa0, 0x10, 0x63, 0x0b, 0x43, 0x16, 0xb6, 0x8b, + 0x92, 0x96, 0xba, 0x52, 0x70, 0xa3, 0x88, 0x08, 0x42, 0x41, 0x14, 0x97, 0x61, 0x4c, 0x6e, 0xe2, + 0x60, 0x3a, 0x53, 0x67, 0x6e, 0x04, 0x5d, 0x89, 0xaf, 0xe2, 0x33, 0xf4, 0x01, 0x7c, 0x33, 0xf3, + 0x87, 0x56, 0xac, 0xb5, 0xdd, 0x25, 0x37, 0xe7, 0xdc, 0x9c, 0x9f, 0x4b, 0x3a, 0x06, 0x81, 0x8f, + 0xc7, 0x60, 0x0c, 0x8f, 0xc1, 0xf8, 0x2a, 0x8a, 0x12, 0x21, 0xc1, 0x2b, 0xa6, 0x41, 0x22, 0x40, + 0xa2, 0x37, 0xd1, 0x0a, 0x95, 0xd3, 0xfb, 0x0e, 0x4c, 0xa5, 0x88, 0x04, 0x84, 0xfe, 0x2d, 0x37, + 0x73, 0xd0, 0xee, 0x21, 0xd9, 0x3b, 0x19, 0x95, 0xbb, 0xfc, 0x33, 0xc0, 0xea, 0xf1, 0x42, 0xc5, + 0x4a, 0x5e, 0x89, 0xe0, 0x1e, 0xd0, 0xbf, 0x84, 0x87, 0x14, 0x0c, 0xd2, 0x6d, 0xb2, 0x36, 0xd1, + 0x42, 0x69, 0x81, 0x4f, 0xb6, 0xc5, 0xac, 0xee, 0x96, 0x7b, 0x43, 0x3a, 0x7f, 0x72, 0xcd, 0x44, + 0x49, 0x03, 0x74, 0x87, 0x34, 0x0c, 0x68, 0xc1, 0x13, 0xf1, 0x9c, 0x69, 0xc1, 0xe2, 0x6b, 0xb1, + 0x65, 0x93, 0x36, 0xc8, 0xba, 0x11, 0xb1, 0xe4, 0x98, 0x6a, 0xb0, 0xff, 0xe5, 0x23, 0x77, 0x40, + 0xbc, 0xd9, 0xc5, 0xd7, 0x32, 0x07, 0x40, 0xf8, 0xbb, 0x38, 0x77, 0x44, 0x76, 0x3f, 0x19, 0x3f, + 0x61, 0xf9, 0x3f, 0x78, 0x10, 0xa8, 0x54, 0xa2, 0x08, 0x4b, 0xf1, 0xb4, 0x4d, 0x9a, 0x1a, 0xc5, + 0x18, 0xf6, 0x87, 0x7e, 0xa0, 0x81, 0xa3, 0x50, 0xd2, 0xcf, 0xdf, 0x0b, 0x09, 0x75, 0xd7, 0x27, + 0xfd, 0xa5, 0x25, 0x54, 0x1e, 0x7b, 0xe4, 0xff, 0x8c, 0xb1, 0x8d, 0x61, 0xcb, 0x5b, 0x20, 0x69, + 0xf8, 0x56, 0x23, 0xf5, 0x6a, 0x4c, 0xa7, 0x16, 0x69, 0xce, 0x0d, 0x90, 0x76, 0xbc, 0xe5, 0xda, + 0x71, 0xba, 0xde, 0x92, 0x55, 0xb8, 0xe7, 0xaf, 0x53, 0xfb, 0x34, 0xc3, 0x30, 0xce, 0xbe, 0x2a, + 0x61, 0x5c, 0x86, 0xac, 0xb4, 0xc8, 0xaa, 0xd3, 0x62, 0x49, 0xce, 0x66, 0xa5, 0x25, 0x16, 0x29, + 0xcd, 0xf0, 0x0e, 0x58, 0x90, 0x6a, 0x9d, 0x5d, 0x0f, 0x4b, 0x33, 0x2e, 0x7d, 0xb7, 0x48, 0x7b, + 0x61, 0x38, 0xb4, 0xbf, 0x62, 0x91, 0xce, 0xc0, 0x5b, 0x31, 0x76, 0xf7, 0x28, 0xf3, 0x73, 0x50, + 0xf8, 0x91, 0x2c, 0x95, 0xab, 0x7a, 0x70, 0x5a, 0x19, 0xdd, 0xae, 0xf6, 0x67, 0x81, 0x20, 0x0a, + 0x19, 0x9b, 0x3c, 0x99, 0x47, 0x11, 0xc0, 0x71, 0xed, 0xc5, 0xb2, 0x3e, 0x02, 0x00, 0x00, 0xff, + 0xff, 0x90, 0xd3, 0xb5, 0xf7, 0x7b, 0x03, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/parental.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/parental.pb.go new file mode 100644 index 00000000..5d3dbac0 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/parental.pb.go @@ -0,0 +1,791 @@ +// Code generated by protoc-gen-go. +// source: steammessages_parental.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type ParentalApp struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + IsAllowed *bool `protobuf:"varint,2,opt,name=is_allowed" json:"is_allowed,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ParentalApp) Reset() { *m = ParentalApp{} } +func (m *ParentalApp) String() string { return proto.CompactTextString(m) } +func (*ParentalApp) ProtoMessage() {} +func (*ParentalApp) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{0} } + +func (m *ParentalApp) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *ParentalApp) GetIsAllowed() bool { + if m != nil && m.IsAllowed != nil { + return *m.IsAllowed + } + return false +} + +type ParentalSettings struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + ApplistBaseId *uint32 `protobuf:"varint,2,opt,name=applist_base_id" json:"applist_base_id,omitempty"` + ApplistBaseDescription *string `protobuf:"bytes,3,opt,name=applist_base_description" json:"applist_base_description,omitempty"` + ApplistBase []*ParentalApp `protobuf:"bytes,4,rep,name=applist_base" json:"applist_base,omitempty"` + ApplistCustom []*ParentalApp `protobuf:"bytes,5,rep,name=applist_custom" json:"applist_custom,omitempty"` + Passwordhashtype *uint32 `protobuf:"varint,6,opt,name=passwordhashtype" json:"passwordhashtype,omitempty"` + Salt []byte `protobuf:"bytes,7,opt,name=salt" json:"salt,omitempty"` + Passwordhash []byte `protobuf:"bytes,8,opt,name=passwordhash" json:"passwordhash,omitempty"` + IsEnabled *bool `protobuf:"varint,9,opt,name=is_enabled" json:"is_enabled,omitempty"` + EnabledFeatures *uint32 `protobuf:"varint,10,opt,name=enabled_features" json:"enabled_features,omitempty"` + RecoveryEmail *string `protobuf:"bytes,11,opt,name=recovery_email" json:"recovery_email,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ParentalSettings) Reset() { *m = ParentalSettings{} } +func (m *ParentalSettings) String() string { return proto.CompactTextString(m) } +func (*ParentalSettings) ProtoMessage() {} +func (*ParentalSettings) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{1} } + +func (m *ParentalSettings) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *ParentalSettings) GetApplistBaseId() uint32 { + if m != nil && m.ApplistBaseId != nil { + return *m.ApplistBaseId + } + return 0 +} + +func (m *ParentalSettings) GetApplistBaseDescription() string { + if m != nil && m.ApplistBaseDescription != nil { + return *m.ApplistBaseDescription + } + return "" +} + +func (m *ParentalSettings) GetApplistBase() []*ParentalApp { + if m != nil { + return m.ApplistBase + } + return nil +} + +func (m *ParentalSettings) GetApplistCustom() []*ParentalApp { + if m != nil { + return m.ApplistCustom + } + return nil +} + +func (m *ParentalSettings) GetPasswordhashtype() uint32 { + if m != nil && m.Passwordhashtype != nil { + return *m.Passwordhashtype + } + return 0 +} + +func (m *ParentalSettings) GetSalt() []byte { + if m != nil { + return m.Salt + } + return nil +} + +func (m *ParentalSettings) GetPasswordhash() []byte { + if m != nil { + return m.Passwordhash + } + return nil +} + +func (m *ParentalSettings) GetIsEnabled() bool { + if m != nil && m.IsEnabled != nil { + return *m.IsEnabled + } + return false +} + +func (m *ParentalSettings) GetEnabledFeatures() uint32 { + if m != nil && m.EnabledFeatures != nil { + return *m.EnabledFeatures + } + return 0 +} + +func (m *ParentalSettings) GetRecoveryEmail() string { + if m != nil && m.RecoveryEmail != nil { + return *m.RecoveryEmail + } + return "" +} + +type CParental_EnableParentalSettings_Request struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + Settings *ParentalSettings `protobuf:"bytes,2,opt,name=settings" json:"settings,omitempty"` + Sessionid *string `protobuf:"bytes,3,opt,name=sessionid" json:"sessionid,omitempty"` + Enablecode *uint32 `protobuf:"varint,4,opt,name=enablecode" json:"enablecode,omitempty"` + Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_EnableParentalSettings_Request) Reset() { + *m = CParental_EnableParentalSettings_Request{} +} +func (m *CParental_EnableParentalSettings_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_EnableParentalSettings_Request) ProtoMessage() {} +func (*CParental_EnableParentalSettings_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{2} +} + +func (m *CParental_EnableParentalSettings_Request) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CParental_EnableParentalSettings_Request) GetSettings() *ParentalSettings { + if m != nil { + return m.Settings + } + return nil +} + +func (m *CParental_EnableParentalSettings_Request) GetSessionid() string { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return "" +} + +func (m *CParental_EnableParentalSettings_Request) GetEnablecode() uint32 { + if m != nil && m.Enablecode != nil { + return *m.Enablecode + } + return 0 +} + +func (m *CParental_EnableParentalSettings_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CParental_EnableParentalSettings_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_EnableParentalSettings_Response) Reset() { + *m = CParental_EnableParentalSettings_Response{} +} +func (m *CParental_EnableParentalSettings_Response) String() string { return proto.CompactTextString(m) } +func (*CParental_EnableParentalSettings_Response) ProtoMessage() {} +func (*CParental_EnableParentalSettings_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{3} +} + +type CParental_DisableParentalSettings_Request struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_DisableParentalSettings_Request) Reset() { + *m = CParental_DisableParentalSettings_Request{} +} +func (m *CParental_DisableParentalSettings_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_DisableParentalSettings_Request) ProtoMessage() {} +func (*CParental_DisableParentalSettings_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{4} +} + +func (m *CParental_DisableParentalSettings_Request) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CParental_DisableParentalSettings_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CParental_DisableParentalSettings_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_DisableParentalSettings_Response) Reset() { + *m = CParental_DisableParentalSettings_Response{} +} +func (m *CParental_DisableParentalSettings_Response) String() string { + return proto.CompactTextString(m) +} +func (*CParental_DisableParentalSettings_Response) ProtoMessage() {} +func (*CParental_DisableParentalSettings_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{5} +} + +type CParental_GetParentalSettings_Request struct { + Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_GetParentalSettings_Request) Reset() { *m = CParental_GetParentalSettings_Request{} } +func (m *CParental_GetParentalSettings_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_GetParentalSettings_Request) ProtoMessage() {} +func (*CParental_GetParentalSettings_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{6} +} + +func (m *CParental_GetParentalSettings_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CParental_GetParentalSettings_Response struct { + Settings *ParentalSettings `protobuf:"bytes,1,opt,name=settings" json:"settings,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_GetParentalSettings_Response) Reset() { + *m = CParental_GetParentalSettings_Response{} +} +func (m *CParental_GetParentalSettings_Response) String() string { return proto.CompactTextString(m) } +func (*CParental_GetParentalSettings_Response) ProtoMessage() {} +func (*CParental_GetParentalSettings_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{7} +} + +func (m *CParental_GetParentalSettings_Response) GetSettings() *ParentalSettings { + if m != nil { + return m.Settings + } + return nil +} + +type CParental_GetSignedParentalSettings_Request struct { + Priority *uint32 `protobuf:"varint,1,opt,name=priority" json:"priority,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_GetSignedParentalSettings_Request) Reset() { + *m = CParental_GetSignedParentalSettings_Request{} +} +func (m *CParental_GetSignedParentalSettings_Request) String() string { + return proto.CompactTextString(m) +} +func (*CParental_GetSignedParentalSettings_Request) ProtoMessage() {} +func (*CParental_GetSignedParentalSettings_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{8} +} + +func (m *CParental_GetSignedParentalSettings_Request) GetPriority() uint32 { + if m != nil && m.Priority != nil { + return *m.Priority + } + return 0 +} + +type CParental_GetSignedParentalSettings_Response struct { + SerializedSettings []byte `protobuf:"bytes,1,opt,name=serialized_settings" json:"serialized_settings,omitempty"` + Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_GetSignedParentalSettings_Response) Reset() { + *m = CParental_GetSignedParentalSettings_Response{} +} +func (m *CParental_GetSignedParentalSettings_Response) String() string { + return proto.CompactTextString(m) +} +func (*CParental_GetSignedParentalSettings_Response) ProtoMessage() {} +func (*CParental_GetSignedParentalSettings_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{9} +} + +func (m *CParental_GetSignedParentalSettings_Response) GetSerializedSettings() []byte { + if m != nil { + return m.SerializedSettings + } + return nil +} + +func (m *CParental_GetSignedParentalSettings_Response) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +type CParental_SetParentalSettings_Request struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + Settings *ParentalSettings `protobuf:"bytes,2,opt,name=settings" json:"settings,omitempty"` + NewPassword *string `protobuf:"bytes,3,opt,name=new_password" json:"new_password,omitempty"` + Sessionid *string `protobuf:"bytes,4,opt,name=sessionid" json:"sessionid,omitempty"` + Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_SetParentalSettings_Request) Reset() { *m = CParental_SetParentalSettings_Request{} } +func (m *CParental_SetParentalSettings_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_SetParentalSettings_Request) ProtoMessage() {} +func (*CParental_SetParentalSettings_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{10} +} + +func (m *CParental_SetParentalSettings_Request) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CParental_SetParentalSettings_Request) GetSettings() *ParentalSettings { + if m != nil { + return m.Settings + } + return nil +} + +func (m *CParental_SetParentalSettings_Request) GetNewPassword() string { + if m != nil && m.NewPassword != nil { + return *m.NewPassword + } + return "" +} + +func (m *CParental_SetParentalSettings_Request) GetSessionid() string { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return "" +} + +func (m *CParental_SetParentalSettings_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CParental_SetParentalSettings_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_SetParentalSettings_Response) Reset() { + *m = CParental_SetParentalSettings_Response{} +} +func (m *CParental_SetParentalSettings_Response) String() string { return proto.CompactTextString(m) } +func (*CParental_SetParentalSettings_Response) ProtoMessage() {} +func (*CParental_SetParentalSettings_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{11} +} + +type CParental_ValidateToken_Request struct { + UnlockToken *string `protobuf:"bytes,1,opt,name=unlock_token" json:"unlock_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_ValidateToken_Request) Reset() { *m = CParental_ValidateToken_Request{} } +func (m *CParental_ValidateToken_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_ValidateToken_Request) ProtoMessage() {} +func (*CParental_ValidateToken_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{12} +} + +func (m *CParental_ValidateToken_Request) GetUnlockToken() string { + if m != nil && m.UnlockToken != nil { + return *m.UnlockToken + } + return "" +} + +type CParental_ValidateToken_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_ValidateToken_Response) Reset() { *m = CParental_ValidateToken_Response{} } +func (m *CParental_ValidateToken_Response) String() string { return proto.CompactTextString(m) } +func (*CParental_ValidateToken_Response) ProtoMessage() {} +func (*CParental_ValidateToken_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{13} +} + +type CParental_ValidatePassword_Request struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + Session *string `protobuf:"bytes,2,opt,name=session" json:"session,omitempty"` + SendUnlockOnSuccess *bool `protobuf:"varint,3,opt,name=send_unlock_on_success" json:"send_unlock_on_success,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_ValidatePassword_Request) Reset() { *m = CParental_ValidatePassword_Request{} } +func (m *CParental_ValidatePassword_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_ValidatePassword_Request) ProtoMessage() {} +func (*CParental_ValidatePassword_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{14} +} + +func (m *CParental_ValidatePassword_Request) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CParental_ValidatePassword_Request) GetSession() string { + if m != nil && m.Session != nil { + return *m.Session + } + return "" +} + +func (m *CParental_ValidatePassword_Request) GetSendUnlockOnSuccess() bool { + if m != nil && m.SendUnlockOnSuccess != nil { + return *m.SendUnlockOnSuccess + } + return false +} + +type CParental_ValidatePassword_Response struct { + Token *string `protobuf:"bytes,1,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_ValidatePassword_Response) Reset() { *m = CParental_ValidatePassword_Response{} } +func (m *CParental_ValidatePassword_Response) String() string { return proto.CompactTextString(m) } +func (*CParental_ValidatePassword_Response) ProtoMessage() {} +func (*CParental_ValidatePassword_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{15} +} + +func (m *CParental_ValidatePassword_Response) GetToken() string { + if m != nil && m.Token != nil { + return *m.Token + } + return "" +} + +type CParental_LockClient_Request struct { + Session *string `protobuf:"bytes,1,opt,name=session" json:"session,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_LockClient_Request) Reset() { *m = CParental_LockClient_Request{} } +func (m *CParental_LockClient_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_LockClient_Request) ProtoMessage() {} +func (*CParental_LockClient_Request) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{16} } + +func (m *CParental_LockClient_Request) GetSession() string { + if m != nil && m.Session != nil { + return *m.Session + } + return "" +} + +type CParental_LockClient_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_LockClient_Response) Reset() { *m = CParental_LockClient_Response{} } +func (m *CParental_LockClient_Response) String() string { return proto.CompactTextString(m) } +func (*CParental_LockClient_Response) ProtoMessage() {} +func (*CParental_LockClient_Response) Descriptor() ([]byte, []int) { return parental_fileDescriptor0, []int{17} } + +type CParental_RequestRecoveryCode_Request struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_RequestRecoveryCode_Request) Reset() { *m = CParental_RequestRecoveryCode_Request{} } +func (m *CParental_RequestRecoveryCode_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_RequestRecoveryCode_Request) ProtoMessage() {} +func (*CParental_RequestRecoveryCode_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{18} +} + +type CParental_RequestRecoveryCode_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_RequestRecoveryCode_Response) Reset() { + *m = CParental_RequestRecoveryCode_Response{} +} +func (m *CParental_RequestRecoveryCode_Response) String() string { return proto.CompactTextString(m) } +func (*CParental_RequestRecoveryCode_Response) ProtoMessage() {} +func (*CParental_RequestRecoveryCode_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{19} +} + +type CParental_DisableWithRecoveryCode_Request struct { + RecoveryCode *uint32 `protobuf:"varint,1,opt,name=recovery_code" json:"recovery_code,omitempty"` + Steamid *uint64 `protobuf:"fixed64,10,opt,name=steamid" json:"steamid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_DisableWithRecoveryCode_Request) Reset() { + *m = CParental_DisableWithRecoveryCode_Request{} +} +func (m *CParental_DisableWithRecoveryCode_Request) String() string { return proto.CompactTextString(m) } +func (*CParental_DisableWithRecoveryCode_Request) ProtoMessage() {} +func (*CParental_DisableWithRecoveryCode_Request) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{20} +} + +func (m *CParental_DisableWithRecoveryCode_Request) GetRecoveryCode() uint32 { + if m != nil && m.RecoveryCode != nil { + return *m.RecoveryCode + } + return 0 +} + +func (m *CParental_DisableWithRecoveryCode_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +type CParental_DisableWithRecoveryCode_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_DisableWithRecoveryCode_Response) Reset() { + *m = CParental_DisableWithRecoveryCode_Response{} +} +func (m *CParental_DisableWithRecoveryCode_Response) String() string { + return proto.CompactTextString(m) +} +func (*CParental_DisableWithRecoveryCode_Response) ProtoMessage() {} +func (*CParental_DisableWithRecoveryCode_Response) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{21} +} + +type CParental_ParentalSettingsChange_Notification struct { + SerializedSettings []byte `protobuf:"bytes,1,opt,name=serialized_settings" json:"serialized_settings,omitempty"` + Signature []byte `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"` + Password *string `protobuf:"bytes,3,opt,name=password" json:"password,omitempty"` + Sessionid *string `protobuf:"bytes,4,opt,name=sessionid" json:"sessionid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_ParentalSettingsChange_Notification) Reset() { + *m = CParental_ParentalSettingsChange_Notification{} +} +func (m *CParental_ParentalSettingsChange_Notification) String() string { + return proto.CompactTextString(m) +} +func (*CParental_ParentalSettingsChange_Notification) ProtoMessage() {} +func (*CParental_ParentalSettingsChange_Notification) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{22} +} + +func (m *CParental_ParentalSettingsChange_Notification) GetSerializedSettings() []byte { + if m != nil { + return m.SerializedSettings + } + return nil +} + +func (m *CParental_ParentalSettingsChange_Notification) GetSignature() []byte { + if m != nil { + return m.Signature + } + return nil +} + +func (m *CParental_ParentalSettingsChange_Notification) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CParental_ParentalSettingsChange_Notification) GetSessionid() string { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return "" +} + +type CParental_ParentalUnlock_Notification struct { + Password *string `protobuf:"bytes,1,opt,name=password" json:"password,omitempty"` + Sessionid *string `protobuf:"bytes,2,opt,name=sessionid" json:"sessionid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_ParentalUnlock_Notification) Reset() { *m = CParental_ParentalUnlock_Notification{} } +func (m *CParental_ParentalUnlock_Notification) String() string { return proto.CompactTextString(m) } +func (*CParental_ParentalUnlock_Notification) ProtoMessage() {} +func (*CParental_ParentalUnlock_Notification) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{23} +} + +func (m *CParental_ParentalUnlock_Notification) GetPassword() string { + if m != nil && m.Password != nil { + return *m.Password + } + return "" +} + +func (m *CParental_ParentalUnlock_Notification) GetSessionid() string { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return "" +} + +type CParental_ParentalLock_Notification struct { + Sessionid *string `protobuf:"bytes,1,opt,name=sessionid" json:"sessionid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CParental_ParentalLock_Notification) Reset() { *m = CParental_ParentalLock_Notification{} } +func (m *CParental_ParentalLock_Notification) String() string { return proto.CompactTextString(m) } +func (*CParental_ParentalLock_Notification) ProtoMessage() {} +func (*CParental_ParentalLock_Notification) Descriptor() ([]byte, []int) { + return parental_fileDescriptor0, []int{24} +} + +func (m *CParental_ParentalLock_Notification) GetSessionid() string { + if m != nil && m.Sessionid != nil { + return *m.Sessionid + } + return "" +} + +func init() { + proto.RegisterType((*ParentalApp)(nil), "ParentalApp") + proto.RegisterType((*ParentalSettings)(nil), "ParentalSettings") + proto.RegisterType((*CParental_EnableParentalSettings_Request)(nil), "CParental_EnableParentalSettings_Request") + proto.RegisterType((*CParental_EnableParentalSettings_Response)(nil), "CParental_EnableParentalSettings_Response") + proto.RegisterType((*CParental_DisableParentalSettings_Request)(nil), "CParental_DisableParentalSettings_Request") + proto.RegisterType((*CParental_DisableParentalSettings_Response)(nil), "CParental_DisableParentalSettings_Response") + proto.RegisterType((*CParental_GetParentalSettings_Request)(nil), "CParental_GetParentalSettings_Request") + proto.RegisterType((*CParental_GetParentalSettings_Response)(nil), "CParental_GetParentalSettings_Response") + proto.RegisterType((*CParental_GetSignedParentalSettings_Request)(nil), "CParental_GetSignedParentalSettings_Request") + proto.RegisterType((*CParental_GetSignedParentalSettings_Response)(nil), "CParental_GetSignedParentalSettings_Response") + proto.RegisterType((*CParental_SetParentalSettings_Request)(nil), "CParental_SetParentalSettings_Request") + proto.RegisterType((*CParental_SetParentalSettings_Response)(nil), "CParental_SetParentalSettings_Response") + proto.RegisterType((*CParental_ValidateToken_Request)(nil), "CParental_ValidateToken_Request") + proto.RegisterType((*CParental_ValidateToken_Response)(nil), "CParental_ValidateToken_Response") + proto.RegisterType((*CParental_ValidatePassword_Request)(nil), "CParental_ValidatePassword_Request") + proto.RegisterType((*CParental_ValidatePassword_Response)(nil), "CParental_ValidatePassword_Response") + proto.RegisterType((*CParental_LockClient_Request)(nil), "CParental_LockClient_Request") + proto.RegisterType((*CParental_LockClient_Response)(nil), "CParental_LockClient_Response") + proto.RegisterType((*CParental_RequestRecoveryCode_Request)(nil), "CParental_RequestRecoveryCode_Request") + proto.RegisterType((*CParental_RequestRecoveryCode_Response)(nil), "CParental_RequestRecoveryCode_Response") + proto.RegisterType((*CParental_DisableWithRecoveryCode_Request)(nil), "CParental_DisableWithRecoveryCode_Request") + proto.RegisterType((*CParental_DisableWithRecoveryCode_Response)(nil), "CParental_DisableWithRecoveryCode_Response") + proto.RegisterType((*CParental_ParentalSettingsChange_Notification)(nil), "CParental_ParentalSettingsChange_Notification") + proto.RegisterType((*CParental_ParentalUnlock_Notification)(nil), "CParental_ParentalUnlock_Notification") + proto.RegisterType((*CParental_ParentalLock_Notification)(nil), "CParental_ParentalLock_Notification") +} + +var parental_fileDescriptor0 = []byte{ + // 1337 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x57, 0x41, 0x8f, 0x14, 0xc5, + 0x17, 0x4f, 0xc3, 0x02, 0xbb, 0xb5, 0xb3, 0xcb, 0x52, 0xf0, 0x87, 0x66, 0xfe, 0x02, 0x65, 0x2f, + 0xc2, 0x02, 0x4b, 0x6b, 0x56, 0x23, 0x26, 0x26, 0x12, 0x58, 0x0d, 0x26, 0x2e, 0x88, 0x0c, 0x8a, + 0x09, 0x89, 0x9d, 0xda, 0xee, 0xda, 0xd9, 0x92, 0x9e, 0xaa, 0xb6, 0xab, 0x86, 0x75, 0x3d, 0x19, + 0x63, 0xbc, 0x19, 0x2f, 0x1e, 0x34, 0xf1, 0x6e, 0xa2, 0x5e, 0x89, 0x57, 0x13, 0xbf, 0x80, 0xf1, + 0x53, 0xf8, 0x31, 0x7c, 0x5d, 0xd5, 0x3d, 0xd3, 0xbd, 0xd3, 0x33, 0xd3, 0x23, 0xb7, 0x99, 0xaa, + 0xf7, 0x5e, 0xfd, 0xde, 0x7b, 0xbf, 0x7a, 0xbf, 0x6a, 0xb4, 0xa6, 0x34, 0xa3, 0xbd, 0x1e, 0x53, + 0x8a, 0x76, 0x99, 0x0a, 0x12, 0x9a, 0x32, 0xa1, 0x69, 0xec, 0x9b, 0xe5, 0x30, 0xe6, 0xf0, 0xcf, + 0x4f, 0x52, 0xa9, 0x65, 0x7b, 0xbd, 0x6a, 0xd9, 0x17, 0x7c, 0x87, 0xb3, 0x28, 0xd8, 0xa6, 0x8a, + 0x8d, 0x5a, 0x7b, 0xaf, 0xa0, 0xc5, 0xfb, 0x79, 0xac, 0x5b, 0x49, 0x82, 0x97, 0xd0, 0x11, 0x9a, + 0x24, 0x3c, 0x72, 0x1d, 0xe2, 0xac, 0x2d, 0x61, 0x8c, 0x10, 0x57, 0x01, 0x8d, 0x63, 0xb9, 0xc7, + 0x22, 0xf7, 0x10, 0xac, 0xcd, 0x7b, 0xbf, 0x1d, 0x42, 0x2b, 0x85, 0x4b, 0x87, 0x69, 0xcd, 0x45, + 0x57, 0xe1, 0xe3, 0xe8, 0x98, 0x89, 0x9d, 0x7b, 0x1e, 0xc5, 0x67, 0xd0, 0x71, 0x08, 0x14, 0x73, + 0xa5, 0xcd, 0xc9, 0x01, 0xb7, 0xee, 0x4b, 0x98, 0x20, 0xb7, 0xb2, 0x11, 0x31, 0x15, 0xa6, 0x3c, + 0xd1, 0x5c, 0x0a, 0xf7, 0x30, 0x58, 0x2c, 0x60, 0x0f, 0xb5, 0xca, 0x16, 0xee, 0x1c, 0x39, 0xbc, + 0xb6, 0xb8, 0xd1, 0xf2, 0xcb, 0x38, 0x2f, 0xa2, 0xe5, 0xc2, 0x26, 0xec, 0x2b, 0x2d, 0x7b, 0xee, + 0x91, 0x1a, 0x2b, 0x17, 0xad, 0x24, 0x54, 0xa9, 0x3d, 0x99, 0x46, 0xbb, 0x54, 0xed, 0xea, 0xfd, + 0x84, 0xb9, 0x47, 0x0d, 0x8a, 0x16, 0x9a, 0x53, 0x34, 0xd6, 0xee, 0x31, 0xf8, 0xd7, 0xc2, 0xa7, + 0x50, 0xab, 0x6c, 0xe7, 0xce, 0x9b, 0x55, 0x9b, 0x3c, 0x13, 0x74, 0x3b, 0x86, 0xe4, 0x17, 0xb2, + 0xe4, 0xb3, 0x88, 0xf9, 0x42, 0xb0, 0xc3, 0xa8, 0xee, 0xa7, 0x4c, 0xb9, 0xc8, 0x44, 0x3c, 0x8d, + 0x96, 0x53, 0x16, 0xca, 0xa7, 0x2c, 0xdd, 0x0f, 0x58, 0x8f, 0xf2, 0xd8, 0x5d, 0xcc, 0xb2, 0xf1, + 0x7e, 0x74, 0xd0, 0xda, 0x66, 0x01, 0x2a, 0x78, 0xc7, 0x38, 0x1f, 0x2c, 0x5f, 0xf0, 0x80, 0x7d, + 0xd6, 0x67, 0x4a, 0xe3, 0x15, 0x34, 0x5f, 0x00, 0x31, 0x75, 0x5c, 0xc0, 0xab, 0x68, 0x5e, 0xe5, + 0x56, 0xa6, 0x80, 0x8b, 0x1b, 0x27, 0xfc, 0x91, 0xea, 0x9f, 0x40, 0x0b, 0x0a, 0xfa, 0x0d, 0x25, + 0x84, 0x32, 0xdb, 0x22, 0x02, 0x78, 0x0b, 0x34, 0x94, 0x51, 0x56, 0xc2, 0x0c, 0x62, 0xa9, 0x49, + 0x19, 0xe6, 0xa3, 0xde, 0x35, 0x74, 0xa5, 0x01, 0x34, 0x95, 0x48, 0xa1, 0x98, 0x77, 0xaf, 0x6c, + 0xfc, 0x36, 0x57, 0x33, 0x26, 0x32, 0x72, 0xf8, 0x3a, 0xba, 0xda, 0x24, 0x5e, 0x7e, 0xfa, 0x1b, + 0xe8, 0xa5, 0xa1, 0xf5, 0x1d, 0xa6, 0xc7, 0x9e, 0x3c, 0x72, 0xce, 0x5d, 0x74, 0x69, 0x9a, 0xa7, + 0x3d, 0xa3, 0x52, 0x6b, 0x67, 0x4c, 0xad, 0xbd, 0x9b, 0xe8, 0x5a, 0x25, 0x5c, 0x87, 0x77, 0x05, + 0x8b, 0x26, 0x16, 0x22, 0xe5, 0x32, 0xe5, 0x7a, 0xdf, 0xde, 0x29, 0xef, 0x13, 0xb4, 0xde, 0x2c, + 0x40, 0x8e, 0xea, 0xff, 0xe8, 0xa4, 0x62, 0x29, 0xa7, 0x31, 0xff, 0x02, 0x58, 0x57, 0x01, 0xd8, + 0x32, 0x9d, 0x07, 0x7f, 0xc3, 0x44, 0xc3, 0x8f, 0x96, 0xf7, 0x83, 0x53, 0x2e, 0x55, 0x67, 0x42, + 0xa9, 0xfe, 0x23, 0xdb, 0xe0, 0xb6, 0x08, 0xb6, 0x17, 0x0c, 0x5c, 0x2d, 0xe1, 0x2a, 0x1c, 0x9c, + 0xab, 0x6f, 0xf9, 0x5a, 0xb9, 0x15, 0x9d, 0x09, 0xad, 0xf0, 0x6e, 0xa0, 0x0b, 0x43, 0xcb, 0x8f, + 0x20, 0xf7, 0x88, 0x6a, 0xf6, 0x50, 0x3e, 0x61, 0x62, 0x80, 0x1e, 0x60, 0xf4, 0x45, 0x2c, 0xc3, + 0x27, 0x81, 0xce, 0xd6, 0x6d, 0x06, 0x9e, 0x87, 0xc8, 0x78, 0xc7, 0x3c, 0x78, 0x17, 0x79, 0xa3, + 0x36, 0xf7, 0xf3, 0x74, 0xa6, 0x50, 0xd8, 0xa6, 0x68, 0x8a, 0xb3, 0x80, 0xcf, 0xa3, 0xd3, 0x8a, + 0x89, 0x28, 0xc8, 0x71, 0x48, 0x11, 0xa8, 0x7e, 0x18, 0x82, 0x89, 0xa9, 0xc9, 0xbc, 0xf7, 0x1a, + 0x5a, 0x9d, 0x78, 0x50, 0xde, 0x61, 0x18, 0xba, 0xe5, 0x14, 0x5e, 0x46, 0x2f, 0x0c, 0xbd, 0xb6, + 0x20, 0xf0, 0xa6, 0x19, 0xd8, 0x15, 0x86, 0xe7, 0x30, 0xac, 0xc3, 0x05, 0x74, 0x6e, 0x8c, 0x43, + 0x9e, 0xf0, 0xe5, 0x32, 0x23, 0xf2, 0x30, 0x0f, 0xf2, 0x61, 0xb5, 0x09, 0xf3, 0xa1, 0x58, 0xab, + 0x36, 0xa8, 0xde, 0x30, 0x0f, 0xd9, 0xa9, 0x99, 0x06, 0x8f, 0xb8, 0xde, 0xad, 0x0b, 0x8b, 0xff, + 0x87, 0x96, 0x06, 0xb3, 0xd1, 0xcc, 0x23, 0xa7, 0x7e, 0x1e, 0xd5, 0x8d, 0x84, 0x9a, 0xa0, 0x39, + 0x84, 0xaf, 0x1d, 0x74, 0x7d, 0x68, 0x7e, 0x90, 0x4b, 0x9b, 0xbb, 0x54, 0x74, 0x59, 0x70, 0x4f, + 0x6a, 0xd0, 0xbf, 0x90, 0x66, 0xfa, 0x32, 0xeb, 0x55, 0xaa, 0x50, 0x60, 0x1c, 0xcb, 0xbd, 0xad, + 0x72, 0x71, 0x8b, 0x1f, 0x1f, 0x5a, 0x46, 0x54, 0x4e, 0x1f, 0x25, 0x54, 0x25, 0x9a, 0xa1, 0x14, + 0xcc, 0xb9, 0xd5, 0xd1, 0x68, 0x5b, 0x23, 0xb1, 0x2a, 0x9e, 0x26, 0xd8, 0xc6, 0xdf, 0xcb, 0x68, + 0xbe, 0x70, 0xc0, 0x7f, 0x39, 0xe8, 0x74, 0xfd, 0x40, 0xc7, 0x57, 0xfc, 0xa6, 0x72, 0xd4, 0xbe, + 0xea, 0x37, 0x97, 0x87, 0xe0, 0xab, 0x67, 0xee, 0x63, 0x6b, 0x44, 0x8a, 0xd7, 0x09, 0x29, 0x4a, + 0x4c, 0x76, 0x64, 0x4a, 0xf4, 0x2e, 0x23, 0xb1, 0xec, 0x76, 0x59, 0x44, 0xb8, 0x20, 0x34, 0x0c, + 0x65, 0x5f, 0xe8, 0x75, 0x22, 0x8d, 0xf6, 0xc3, 0x1b, 0x63, 0xbf, 0x30, 0x37, 0x96, 0x61, 0x3f, + 0xcd, 0x82, 0x0c, 0x42, 0xe0, 0x5f, 0x1d, 0x74, 0x66, 0x8c, 0x4c, 0xe0, 0x32, 0xd0, 0x29, 0xd2, + 0xd4, 0xbe, 0xe6, 0xcf, 0x20, 0x3b, 0x37, 0x20, 0xab, 0x57, 0x73, 0xab, 0x59, 0xd2, 0xc2, 0x3f, + 0x3b, 0xe8, 0x64, 0x8d, 0xd8, 0xe0, 0x4b, 0x7e, 0x23, 0x19, 0x6b, 0x5f, 0xf6, 0x9b, 0x89, 0x96, + 0x77, 0x13, 0x10, 0xbe, 0x09, 0x16, 0x95, 0xa2, 0xcd, 0x82, 0xf4, 0x1f, 0x07, 0x9d, 0x1d, 0x2b, + 0x43, 0x78, 0xdd, 0x9f, 0x41, 0xed, 0xda, 0xd7, 0xfd, 0x59, 0xa4, 0xcd, 0x13, 0x80, 0xfd, 0xd3, + 0xe7, 0xc0, 0x6e, 0x7e, 0x66, 0xdb, 0x3d, 0xd8, 0xa7, 0x9a, 0x84, 0x54, 0x90, 0xed, 0x7d, 0x02, + 0xa3, 0xc2, 0xbc, 0x79, 0xb3, 0xdf, 0x99, 0x1f, 0xcc, 0x1e, 0xc6, 0x61, 0xd1, 0x34, 0xa5, 0x33, + 0xa5, 0x29, 0x9d, 0x86, 0x4d, 0xe9, 0x4c, 0x6d, 0x4a, 0xe7, 0x39, 0x9a, 0x02, 0x48, 0x97, 0x2a, + 0xea, 0x85, 0x89, 0x3f, 0x45, 0x10, 0xdb, 0x2f, 0xfa, 0x53, 0x95, 0xef, 0x03, 0xc0, 0x75, 0x77, + 0x73, 0x97, 0x85, 0x4f, 0x08, 0xdf, 0x31, 0x47, 0x77, 0xa1, 0x30, 0x62, 0x08, 0xcd, 0x2a, 0x19, + 0x31, 0x72, 0x44, 0xb8, 0x22, 0xa1, 0x04, 0xec, 0xa1, 0x9e, 0x80, 0xf4, 0x77, 0x07, 0xad, 0x1c, + 0x94, 0x36, 0xbc, 0xea, 0x4f, 0x17, 0xd8, 0xf6, 0x45, 0xbf, 0x81, 0x38, 0x7a, 0x1f, 0x03, 0xe4, + 0x87, 0xc5, 0xb6, 0xc1, 0x90, 0xc4, 0x94, 0x0b, 0xcd, 0x3e, 0xcf, 0x2a, 0x6a, 0xad, 0x27, 0x30, + 0x84, 0x8a, 0x08, 0xfa, 0x0f, 0x33, 0x1d, 0x96, 0x44, 0x25, 0x3d, 0xfc, 0x9d, 0x83, 0xd0, 0x50, + 0x2d, 0xf1, 0x39, 0x7f, 0x92, 0xea, 0xb6, 0xcf, 0xfb, 0x93, 0x35, 0xf6, 0x36, 0xe0, 0x7c, 0xcb, + 0xcc, 0xe8, 0x7d, 0xa8, 0x9a, 0x10, 0x50, 0x35, 0x40, 0x62, 0xbf, 0xb5, 0x94, 0xa5, 0x27, 0x25, + 0xe6, 0x74, 0xf8, 0xc4, 0x20, 0x32, 0x34, 0xac, 0xb0, 0x50, 0xc9, 0x76, 0x2a, 0xf7, 0x40, 0x98, + 0xf0, 0x9f, 0xc0, 0xcf, 0x1a, 0xd5, 0xad, 0xf0, 0x73, 0x82, 0x7c, 0x57, 0xf8, 0x39, 0x51, 0xbd, + 0x1f, 0x03, 0xd8, 0x47, 0xb9, 0x05, 0x9c, 0x5f, 0x88, 0x33, 0xc9, 0xc4, 0x99, 0x6c, 0x33, 0x60, + 0x28, 0x94, 0x4e, 0xcb, 0xe2, 0xf6, 0xd8, 0x4d, 0xf3, 0x55, 0x43, 0x68, 0x14, 0xc1, 0x47, 0xcf, + 0x90, 0xbb, 0x2a, 0x61, 0xa1, 0xbd, 0x6d, 0x05, 0x23, 0x7e, 0x19, 0x0e, 0xea, 0x83, 0xe2, 0x5d, + 0x37, 0xa8, 0xc7, 0xbd, 0x1a, 0xea, 0x06, 0xf5, 0xf8, 0xc7, 0xc0, 0xeb, 0x90, 0xd1, 0xc6, 0x2d, + 0xad, 0x59, 0x2f, 0xa9, 0x64, 0x94, 0x77, 0x5c, 0x8a, 0x7a, 0xb0, 0xed, 0x73, 0xe0, 0x77, 0xf6, + 0xfe, 0xc8, 0xcd, 0x84, 0x6e, 0x3c, 0xe5, 0x21, 0xdb, 0xf8, 0x66, 0x0e, 0x2d, 0x17, 0xbb, 0x39, + 0x4f, 0x7e, 0x72, 0xd0, 0x29, 0xdb, 0xe7, 0xea, 0x53, 0x03, 0xfb, 0xfe, 0x4c, 0xaf, 0x91, 0xf6, + 0xa2, 0x7f, 0x4f, 0x0e, 0xf0, 0xdf, 0x01, 0x1c, 0x9b, 0xe5, 0x6d, 0xb2, 0x93, 0xca, 0x9e, 0xc1, + 0xc1, 0xd2, 0xac, 0x15, 0x96, 0x49, 0x44, 0xee, 0x40, 0x76, 0xa1, 0x89, 0x96, 0x71, 0x67, 0x64, + 0xa6, 0xe0, 0xef, 0x1d, 0xd4, 0xb2, 0xf0, 0xec, 0x1b, 0xa4, 0x42, 0x9e, 0x09, 0xcf, 0x93, 0x2a, + 0x9c, 0xf7, 0x01, 0xce, 0x7b, 0x0d, 0xe0, 0x58, 0x5e, 0x0f, 0x2e, 0xd6, 0x78, 0x6a, 0x7f, 0x0b, + 0x97, 0xcd, 0xc2, 0xca, 0x2e, 0x0f, 0xbe, 0xe8, 0x37, 0x78, 0xe5, 0x54, 0x21, 0x6d, 0x01, 0xa4, + 0x77, 0x1b, 0x43, 0x9a, 0x72, 0xd5, 0xda, 0x3e, 0x44, 0xbb, 0x34, 0xda, 0xf7, 0x3c, 0x86, 0x28, + 0x1d, 0xa3, 0xfe, 0x78, 0xe6, 0x1e, 0xba, 0x7d, 0xf8, 0x4b, 0xc7, 0xf9, 0x37, 0x00, 0x00, 0xff, + 0xff, 0xc4, 0x79, 0x5c, 0x8e, 0x85, 0x11, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/partnerapps.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/partnerapps.pb.go new file mode 100644 index 00000000..bc91c39b --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/partnerapps.pb.go @@ -0,0 +1,456 @@ +// Code generated by protoc-gen-go. +// source: steammessages_partnerapps.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CPartnerApps_RequestUploadToken_Request struct { + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_RequestUploadToken_Request) Reset() { + *m = CPartnerApps_RequestUploadToken_Request{} +} +func (m *CPartnerApps_RequestUploadToken_Request) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_RequestUploadToken_Request) ProtoMessage() {} +func (*CPartnerApps_RequestUploadToken_Request) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{0} +} + +func (m *CPartnerApps_RequestUploadToken_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CPartnerApps_RequestUploadToken_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CPartnerApps_RequestUploadToken_Response struct { + UploadToken *uint64 `protobuf:"varint,1,opt,name=upload_token" json:"upload_token,omitempty"` + Location *string `protobuf:"bytes,2,opt,name=location" json:"location,omitempty"` + RoutingId *uint64 `protobuf:"varint,3,opt,name=routing_id" json:"routing_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_RequestUploadToken_Response) Reset() { + *m = CPartnerApps_RequestUploadToken_Response{} +} +func (m *CPartnerApps_RequestUploadToken_Response) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_RequestUploadToken_Response) ProtoMessage() {} +func (*CPartnerApps_RequestUploadToken_Response) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{1} +} + +func (m *CPartnerApps_RequestUploadToken_Response) GetUploadToken() uint64 { + if m != nil && m.UploadToken != nil { + return *m.UploadToken + } + return 0 +} + +func (m *CPartnerApps_RequestUploadToken_Response) GetLocation() string { + if m != nil && m.Location != nil { + return *m.Location + } + return "" +} + +func (m *CPartnerApps_RequestUploadToken_Response) GetRoutingId() uint64 { + if m != nil && m.RoutingId != nil { + return *m.RoutingId + } + return 0 +} + +type CPartnerApps_FinishUpload_Request struct { + UploadToken *uint64 `protobuf:"varint,1,opt,name=upload_token" json:"upload_token,omitempty"` + RoutingId *uint64 `protobuf:"varint,2,opt,name=routing_id" json:"routing_id,omitempty"` + AppId *uint32 `protobuf:"varint,3,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_FinishUpload_Request) Reset() { *m = CPartnerApps_FinishUpload_Request{} } +func (m *CPartnerApps_FinishUpload_Request) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_FinishUpload_Request) ProtoMessage() {} +func (*CPartnerApps_FinishUpload_Request) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{2} +} + +func (m *CPartnerApps_FinishUpload_Request) GetUploadToken() uint64 { + if m != nil && m.UploadToken != nil { + return *m.UploadToken + } + return 0 +} + +func (m *CPartnerApps_FinishUpload_Request) GetRoutingId() uint64 { + if m != nil && m.RoutingId != nil { + return *m.RoutingId + } + return 0 +} + +func (m *CPartnerApps_FinishUpload_Request) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CPartnerApps_FinishUploadKVSign_Response struct { + SignedInstallscript *string `protobuf:"bytes,1,opt,name=signed_installscript" json:"signed_installscript,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_FinishUploadKVSign_Response) Reset() { + *m = CPartnerApps_FinishUploadKVSign_Response{} +} +func (m *CPartnerApps_FinishUploadKVSign_Response) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_FinishUploadKVSign_Response) ProtoMessage() {} +func (*CPartnerApps_FinishUploadKVSign_Response) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{3} +} + +func (m *CPartnerApps_FinishUploadKVSign_Response) GetSignedInstallscript() string { + if m != nil && m.SignedInstallscript != nil { + return *m.SignedInstallscript + } + return "" +} + +type CPartnerApps_FinishUploadLegacyDRM_Request struct { + UploadToken *uint64 `protobuf:"varint,1,opt,name=upload_token" json:"upload_token,omitempty"` + RoutingId *uint64 `protobuf:"varint,2,opt,name=routing_id" json:"routing_id,omitempty"` + AppId *uint32 `protobuf:"varint,3,opt,name=app_id" json:"app_id,omitempty"` + Flags *uint32 `protobuf:"varint,4,opt,name=flags" json:"flags,omitempty"` + ToolName *string `protobuf:"bytes,5,opt,name=tool_name" json:"tool_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Request) Reset() { + *m = CPartnerApps_FinishUploadLegacyDRM_Request{} +} +func (m *CPartnerApps_FinishUploadLegacyDRM_Request) String() string { + return proto.CompactTextString(m) +} +func (*CPartnerApps_FinishUploadLegacyDRM_Request) ProtoMessage() {} +func (*CPartnerApps_FinishUploadLegacyDRM_Request) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{4} +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetUploadToken() uint64 { + if m != nil && m.UploadToken != nil { + return *m.UploadToken + } + return 0 +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetRoutingId() uint64 { + if m != nil && m.RoutingId != nil { + return *m.RoutingId + } + return 0 +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Request) GetToolName() string { + if m != nil && m.ToolName != nil { + return *m.ToolName + } + return "" +} + +type CPartnerApps_FinishUploadLegacyDRM_Response struct { + FileId *string `protobuf:"bytes,1,opt,name=file_id" json:"file_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Response) Reset() { + *m = CPartnerApps_FinishUploadLegacyDRM_Response{} +} +func (m *CPartnerApps_FinishUploadLegacyDRM_Response) String() string { + return proto.CompactTextString(m) +} +func (*CPartnerApps_FinishUploadLegacyDRM_Response) ProtoMessage() {} +func (*CPartnerApps_FinishUploadLegacyDRM_Response) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{5} +} + +func (m *CPartnerApps_FinishUploadLegacyDRM_Response) GetFileId() string { + if m != nil && m.FileId != nil { + return *m.FileId + } + return "" +} + +type CPartnerApps_FinishUpload_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_FinishUpload_Response) Reset() { *m = CPartnerApps_FinishUpload_Response{} } +func (m *CPartnerApps_FinishUpload_Response) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_FinishUpload_Response) ProtoMessage() {} +func (*CPartnerApps_FinishUpload_Response) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{6} +} + +type CPartnerApps_FindDRMUploads_Request struct { + AppId *int32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_FindDRMUploads_Request) Reset() { *m = CPartnerApps_FindDRMUploads_Request{} } +func (m *CPartnerApps_FindDRMUploads_Request) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_FindDRMUploads_Request) ProtoMessage() {} +func (*CPartnerApps_FindDRMUploads_Request) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{7} +} + +func (m *CPartnerApps_FindDRMUploads_Request) GetAppId() int32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CPartnerApps_ExistingDRMUpload struct { + FileId *string `protobuf:"bytes,1,opt,name=file_id" json:"file_id,omitempty"` + AppId *uint32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + ActorId *int32 `protobuf:"varint,3,opt,name=actor_id" json:"actor_id,omitempty"` + SuppliedName *string `protobuf:"bytes,5,opt,name=supplied_name" json:"supplied_name,omitempty"` + Flags *uint32 `protobuf:"varint,6,opt,name=flags" json:"flags,omitempty"` + ModType *string `protobuf:"bytes,7,opt,name=mod_type" json:"mod_type,omitempty"` + Timestamp *uint32 `protobuf:"fixed32,8,opt,name=timestamp" json:"timestamp,omitempty"` + OrigFileId *string `protobuf:"bytes,9,opt,name=orig_file_id" json:"orig_file_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_ExistingDRMUpload) Reset() { *m = CPartnerApps_ExistingDRMUpload{} } +func (m *CPartnerApps_ExistingDRMUpload) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_ExistingDRMUpload) ProtoMessage() {} +func (*CPartnerApps_ExistingDRMUpload) Descriptor() ([]byte, []int) { return partnerapps_fileDescriptor0, []int{8} } + +func (m *CPartnerApps_ExistingDRMUpload) GetFileId() string { + if m != nil && m.FileId != nil { + return *m.FileId + } + return "" +} + +func (m *CPartnerApps_ExistingDRMUpload) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CPartnerApps_ExistingDRMUpload) GetActorId() int32 { + if m != nil && m.ActorId != nil { + return *m.ActorId + } + return 0 +} + +func (m *CPartnerApps_ExistingDRMUpload) GetSuppliedName() string { + if m != nil && m.SuppliedName != nil { + return *m.SuppliedName + } + return "" +} + +func (m *CPartnerApps_ExistingDRMUpload) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *CPartnerApps_ExistingDRMUpload) GetModType() string { + if m != nil && m.ModType != nil { + return *m.ModType + } + return "" +} + +func (m *CPartnerApps_ExistingDRMUpload) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CPartnerApps_ExistingDRMUpload) GetOrigFileId() string { + if m != nil && m.OrigFileId != nil { + return *m.OrigFileId + } + return "" +} + +type CPartnerApps_FindDRMUploads_Response struct { + Uploads []*CPartnerApps_ExistingDRMUpload `protobuf:"bytes,1,rep,name=uploads" json:"uploads,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_FindDRMUploads_Response) Reset() { *m = CPartnerApps_FindDRMUploads_Response{} } +func (m *CPartnerApps_FindDRMUploads_Response) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_FindDRMUploads_Response) ProtoMessage() {} +func (*CPartnerApps_FindDRMUploads_Response) Descriptor() ([]byte, []int) { + return partnerapps_fileDescriptor0, []int{9} +} + +func (m *CPartnerApps_FindDRMUploads_Response) GetUploads() []*CPartnerApps_ExistingDRMUpload { + if m != nil { + return m.Uploads + } + return nil +} + +type CPartnerApps_Download_Request struct { + FileId *string `protobuf:"bytes,1,opt,name=file_id" json:"file_id,omitempty"` + AppId *int32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_Download_Request) Reset() { *m = CPartnerApps_Download_Request{} } +func (m *CPartnerApps_Download_Request) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_Download_Request) ProtoMessage() {} +func (*CPartnerApps_Download_Request) Descriptor() ([]byte, []int) { return partnerapps_fileDescriptor0, []int{10} } + +func (m *CPartnerApps_Download_Request) GetFileId() string { + if m != nil && m.FileId != nil { + return *m.FileId + } + return "" +} + +func (m *CPartnerApps_Download_Request) GetAppId() int32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +type CPartnerApps_Download_Response struct { + DownloadUrl *string `protobuf:"bytes,1,opt,name=download_url" json:"download_url,omitempty"` + AppId *int32 `protobuf:"varint,2,opt,name=app_id" json:"app_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPartnerApps_Download_Response) Reset() { *m = CPartnerApps_Download_Response{} } +func (m *CPartnerApps_Download_Response) String() string { return proto.CompactTextString(m) } +func (*CPartnerApps_Download_Response) ProtoMessage() {} +func (*CPartnerApps_Download_Response) Descriptor() ([]byte, []int) { return partnerapps_fileDescriptor0, []int{11} } + +func (m *CPartnerApps_Download_Response) GetDownloadUrl() string { + if m != nil && m.DownloadUrl != nil { + return *m.DownloadUrl + } + return "" +} + +func (m *CPartnerApps_Download_Response) GetAppId() int32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func init() { + proto.RegisterType((*CPartnerApps_RequestUploadToken_Request)(nil), "CPartnerApps_RequestUploadToken_Request") + proto.RegisterType((*CPartnerApps_RequestUploadToken_Response)(nil), "CPartnerApps_RequestUploadToken_Response") + proto.RegisterType((*CPartnerApps_FinishUpload_Request)(nil), "CPartnerApps_FinishUpload_Request") + proto.RegisterType((*CPartnerApps_FinishUploadKVSign_Response)(nil), "CPartnerApps_FinishUploadKVSign_Response") + proto.RegisterType((*CPartnerApps_FinishUploadLegacyDRM_Request)(nil), "CPartnerApps_FinishUploadLegacyDRM_Request") + proto.RegisterType((*CPartnerApps_FinishUploadLegacyDRM_Response)(nil), "CPartnerApps_FinishUploadLegacyDRM_Response") + proto.RegisterType((*CPartnerApps_FinishUpload_Response)(nil), "CPartnerApps_FinishUpload_Response") + proto.RegisterType((*CPartnerApps_FindDRMUploads_Request)(nil), "CPartnerApps_FindDRMUploads_Request") + proto.RegisterType((*CPartnerApps_ExistingDRMUpload)(nil), "CPartnerApps_ExistingDRMUpload") + proto.RegisterType((*CPartnerApps_FindDRMUploads_Response)(nil), "CPartnerApps_FindDRMUploads_Response") + proto.RegisterType((*CPartnerApps_Download_Request)(nil), "CPartnerApps_Download_Request") + proto.RegisterType((*CPartnerApps_Download_Response)(nil), "CPartnerApps_Download_Response") +} + +var partnerapps_fileDescriptor0 = []byte{ + // 809 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x96, 0x4f, 0x6f, 0xd3, 0x4a, + 0x14, 0xc5, 0xe5, 0xb6, 0x69, 0x9a, 0xe9, 0x4b, 0xdf, 0x7b, 0x56, 0x2b, 0x45, 0x11, 0xb4, 0xc6, + 0x2d, 0x22, 0xb4, 0xd5, 0x50, 0x15, 0x21, 0x36, 0x08, 0x95, 0xa6, 0x7f, 0x10, 0x05, 0x84, 0x5a, + 0x40, 0x6c, 0x50, 0x34, 0x75, 0x26, 0xe9, 0x08, 0xdb, 0x63, 0x3c, 0x63, 0x68, 0x77, 0x88, 0x15, + 0x1b, 0x3e, 0x00, 0x7b, 0x76, 0x20, 0x24, 0x24, 0xfa, 0xfd, 0xb8, 0x33, 0xb6, 0x13, 0x3b, 0x69, + 0x53, 0x23, 0x84, 0x58, 0x66, 0x7c, 0x7d, 0xee, 0x6f, 0xce, 0xdc, 0x39, 0x31, 0x5a, 0x11, 0x92, + 0x12, 0xcf, 0xa3, 0x42, 0x90, 0x2e, 0x15, 0xad, 0x80, 0x84, 0xd2, 0xa7, 0x21, 0x09, 0x02, 0x81, + 0xf5, 0x13, 0xc7, 0x65, 0xd4, 0x97, 0x38, 0x08, 0xb9, 0xe4, 0xf5, 0xd5, 0x7c, 0x71, 0xe4, 0xb3, + 0x0e, 0xa3, 0xed, 0xd6, 0x21, 0x11, 0x74, 0xb8, 0xda, 0x7e, 0x80, 0xae, 0x35, 0x9f, 0xc4, 0x7a, + 0xf7, 0x40, 0xaf, 0xb5, 0x4f, 0x5f, 0x47, 0x54, 0xc8, 0x67, 0x81, 0xcb, 0x49, 0xfb, 0x29, 0x7f, + 0x45, 0xfd, 0x74, 0xc9, 0xfc, 0x0f, 0x4d, 0x75, 0x98, 0x4b, 0x7d, 0xe2, 0xd1, 0x9a, 0x61, 0x19, + 0x8d, 0x8a, 0x59, 0x45, 0x25, 0x80, 0x60, 0xed, 0xda, 0x18, 0xfc, 0xac, 0xda, 0x1d, 0xd4, 0xb8, + 0x58, 0x4b, 0x04, 0xdc, 0x17, 0xd4, 0x9c, 0x45, 0xff, 0x44, 0x7a, 0xbd, 0x25, 0xd5, 0x03, 0x2d, + 0x38, 0xa1, 0x5a, 0xb8, 0xdc, 0x21, 0x92, 0x71, 0x5f, 0x6b, 0x56, 0x4c, 0x13, 0xa1, 0x90, 0x47, + 0x92, 0xf9, 0xdd, 0x16, 0xf4, 0x19, 0x57, 0x55, 0xf6, 0x4b, 0x74, 0x25, 0xd7, 0x67, 0x87, 0xf9, + 0x4c, 0x1c, 0xc5, 0x6d, 0x7a, 0xb4, 0x67, 0x37, 0xc8, 0xcb, 0x8d, 0xe9, 0xb5, 0x19, 0x34, 0x09, + 0xbb, 0x48, 0xe5, 0xab, 0xf6, 0xfd, 0x81, 0x6d, 0x64, 0xe5, 0xf7, 0x9e, 0x1f, 0xb0, 0x6e, 0x66, + 0x1b, 0x97, 0xd0, 0xac, 0x80, 0x05, 0xf0, 0x97, 0xf9, 0x42, 0x12, 0xd7, 0x15, 0x4e, 0xc8, 0x02, + 0x19, 0xfb, 0x63, 0x7f, 0x30, 0xd0, 0xf2, 0xb9, 0x52, 0x0f, 0x69, 0x97, 0x38, 0x27, 0x5b, 0xfb, + 0x8f, 0x7e, 0x1f, 0x59, 0x1d, 0x44, 0xc7, 0x25, 0x5d, 0x51, 0x9b, 0xd0, 0x3f, 0xff, 0x47, 0x15, + 0xc9, 0xb9, 0xdb, 0xd2, 0x47, 0x55, 0xd2, 0x28, 0x77, 0xd1, 0x4a, 0x21, 0x92, 0x64, 0x5f, 0xff, + 0xa2, 0xb2, 0x3a, 0x6b, 0xd5, 0x21, 0xde, 0xca, 0x12, 0xb2, 0x47, 0x79, 0x1e, 0xbf, 0x66, 0xdf, + 0x42, 0x8b, 0x83, 0x55, 0x6d, 0xd0, 0x8d, 0xcb, 0x7a, 0x03, 0x91, 0xc1, 0x57, 0xe2, 0x25, 0xfb, + 0x87, 0x81, 0xe6, 0x73, 0xef, 0x6d, 0x1f, 0x33, 0xa1, 0x76, 0xdc, 0x7b, 0x77, 0x08, 0x28, 0xa3, + 0xa1, 0x87, 0x4f, 0x8d, 0x0e, 0x71, 0x24, 0x0f, 0x53, 0x53, 0x4a, 0xe6, 0x1c, 0xaa, 0x8a, 0x28, + 0x08, 0x5c, 0x35, 0xfd, 0x7d, 0x27, 0xfa, 0x5e, 0x4d, 0xa6, 0xef, 0x79, 0x1c, 0x1c, 0x3f, 0x09, + 0x68, 0xad, 0xac, 0x0b, 0x94, 0x7b, 0x0c, 0xee, 0x8f, 0x24, 0x5e, 0x50, 0x9b, 0x82, 0xa5, 0xb2, + 0x3a, 0x19, 0x1e, 0xb2, 0x6e, 0x2b, 0x45, 0xa8, 0x68, 0x4f, 0x5e, 0xa0, 0xa5, 0xd1, 0xbb, 0x4d, + 0xcc, 0x5c, 0x43, 0xe5, 0xf8, 0x5c, 0x05, 0xb0, 0x8f, 0x37, 0xa6, 0xd7, 0x17, 0xf0, 0xe8, 0xdd, + 0xda, 0x1b, 0xe8, 0x72, 0xae, 0x62, 0x8b, 0xbf, 0xf5, 0x73, 0xd3, 0x7d, 0x81, 0x1d, 0x25, 0x7b, + 0x67, 0xc0, 0xd1, 0x8c, 0x42, 0xff, 0x06, 0xb6, 0xd3, 0xc5, 0x28, 0x74, 0xcf, 0xd6, 0x59, 0xff, + 0x8a, 0xd0, 0x74, 0x46, 0xc7, 0xfc, 0x6e, 0xa0, 0x5a, 0x02, 0x11, 0xdf, 0x85, 0xcc, 0xed, 0x36, + 0x1b, 0xb8, 0x60, 0x96, 0xd4, 0xaf, 0xe3, 0xa2, 0x49, 0x61, 0x6f, 0xbc, 0x3f, 0xad, 0xdd, 0x49, + 0x0a, 0xac, 0xd8, 0x47, 0x4b, 0xdf, 0x0f, 0xab, 0xc3, 0x43, 0x2b, 0x77, 0xed, 0x2c, 0xe5, 0x49, + 0x5a, 0x73, 0xc3, 0x52, 0x37, 0x13, 0x6c, 0x35, 0xbf, 0x19, 0x68, 0x2e, 0x11, 0xe8, 0x59, 0xfc, + 0xd7, 0x80, 0xe9, 0x31, 0x75, 0x22, 0x49, 0x0e, 0x01, 0x34, 0x4f, 0x0b, 0x79, 0xec, 0x40, 0x68, + 0x2b, 0xe0, 0xd3, 0x3e, 0x70, 0x73, 0x7b, 0xf7, 0x8f, 0x03, 0xef, 0x02, 0x70, 0xf3, 0x5c, 0x60, + 0x27, 0x12, 0x92, 0x7b, 0x85, 0xb8, 0xbf, 0x18, 0xc8, 0x1c, 0x4e, 0x4b, 0xd3, 0xc6, 0x17, 0xc6, + 0xf5, 0x20, 0xee, 0x88, 0xcc, 0xb5, 0x77, 0x00, 0x77, 0xb3, 0xc9, 0x3d, 0x8f, 0x49, 0xcb, 0xa3, + 0xf2, 0x88, 0x2b, 0x5a, 0x7d, 0xd8, 0x16, 0xf1, 0x07, 0x06, 0x82, 0x74, 0x24, 0x0d, 0xd5, 0x72, + 0x82, 0xcb, 0x84, 0xe5, 0x70, 0x2f, 0x70, 0xa9, 0xa4, 0xe6, 0x67, 0x70, 0x39, 0xdb, 0xa7, 0x1f, + 0x36, 0x2b, 0xb8, 0x78, 0x6a, 0xd7, 0x57, 0xf1, 0x2f, 0x04, 0xab, 0xbd, 0x06, 0xf0, 0xab, 0x79, + 0xf8, 0xb3, 0xa6, 0x22, 0x63, 0xea, 0xa7, 0x01, 0xcc, 0xde, 0x44, 0x14, 0xf2, 0x75, 0x11, 0x17, + 0x88, 0xed, 0xdb, 0x00, 0x75, 0x73, 0x18, 0xea, 0x9c, 0x93, 0xcf, 0xb0, 0x7d, 0x34, 0xd0, 0x4c, + 0x3e, 0xf5, 0xcc, 0x25, 0x5c, 0xe0, 0x1f, 0xa0, 0x7e, 0x15, 0x17, 0x49, 0x4e, 0x1b, 0x03, 0xd8, + 0xb2, 0x7a, 0x28, 0xac, 0xc7, 0x96, 0xc7, 0x61, 0x3c, 0x43, 0xea, 0xc0, 0xc7, 0x0b, 0x30, 0x30, + 0x00, 0x4c, 0x52, 0xd5, 0x3a, 0x3c, 0xb1, 0xf4, 0x77, 0x88, 0xb9, 0x87, 0xa6, 0xd2, 0xa0, 0x33, + 0xe7, 0xf1, 0xc8, 0x08, 0xad, 0x2f, 0xe0, 0xd1, 0x01, 0x59, 0x5f, 0x87, 0xe6, 0xf8, 0x80, 0x86, + 0x6f, 0x98, 0x43, 0x13, 0x5b, 0x84, 0xf6, 0x05, 0x7a, 0x59, 0x1e, 0xf1, 0xe1, 0xf3, 0xca, 0x53, + 0x2c, 0xd0, 0x3d, 0xf9, 0x22, 0x13, 0x9b, 0xe3, 0xef, 0x0c, 0xe3, 0x67, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xec, 0x20, 0xc0, 0x4b, 0xaf, 0x09, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/player.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/player.pb.go new file mode 100644 index 00000000..996005f8 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/player.pb.go @@ -0,0 +1,586 @@ +// Code generated by protoc-gen-go. +// source: steammessages_player.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type CPlayer_GetGameBadgeLevels_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_GetGameBadgeLevels_Request) Reset() { *m = CPlayer_GetGameBadgeLevels_Request{} } +func (m *CPlayer_GetGameBadgeLevels_Request) String() string { return proto.CompactTextString(m) } +func (*CPlayer_GetGameBadgeLevels_Request) ProtoMessage() {} +func (*CPlayer_GetGameBadgeLevels_Request) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{0} +} + +func (m *CPlayer_GetGameBadgeLevels_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +type CPlayer_GetGameBadgeLevels_Response struct { + PlayerLevel *uint32 `protobuf:"varint,1,opt,name=player_level" json:"player_level,omitempty"` + Badges []*CPlayer_GetGameBadgeLevels_Response_Badge `protobuf:"bytes,2,rep,name=badges" json:"badges,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_GetGameBadgeLevels_Response) Reset() { *m = CPlayer_GetGameBadgeLevels_Response{} } +func (m *CPlayer_GetGameBadgeLevels_Response) String() string { return proto.CompactTextString(m) } +func (*CPlayer_GetGameBadgeLevels_Response) ProtoMessage() {} +func (*CPlayer_GetGameBadgeLevels_Response) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{1} +} + +func (m *CPlayer_GetGameBadgeLevels_Response) GetPlayerLevel() uint32 { + if m != nil && m.PlayerLevel != nil { + return *m.PlayerLevel + } + return 0 +} + +func (m *CPlayer_GetGameBadgeLevels_Response) GetBadges() []*CPlayer_GetGameBadgeLevels_Response_Badge { + if m != nil { + return m.Badges + } + return nil +} + +type CPlayer_GetGameBadgeLevels_Response_Badge struct { + Level *int32 `protobuf:"varint,1,opt,name=level" json:"level,omitempty"` + Series *int32 `protobuf:"varint,2,opt,name=series" json:"series,omitempty"` + BorderColor *uint32 `protobuf:"varint,3,opt,name=border_color" json:"border_color,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_GetGameBadgeLevels_Response_Badge) Reset() { + *m = CPlayer_GetGameBadgeLevels_Response_Badge{} +} +func (m *CPlayer_GetGameBadgeLevels_Response_Badge) String() string { return proto.CompactTextString(m) } +func (*CPlayer_GetGameBadgeLevels_Response_Badge) ProtoMessage() {} +func (*CPlayer_GetGameBadgeLevels_Response_Badge) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{1, 0} +} + +func (m *CPlayer_GetGameBadgeLevels_Response_Badge) GetLevel() int32 { + if m != nil && m.Level != nil { + return *m.Level + } + return 0 +} + +func (m *CPlayer_GetGameBadgeLevels_Response_Badge) GetSeries() int32 { + if m != nil && m.Series != nil { + return *m.Series + } + return 0 +} + +func (m *CPlayer_GetGameBadgeLevels_Response_Badge) GetBorderColor() uint32 { + if m != nil && m.BorderColor != nil { + return *m.BorderColor + } + return 0 +} + +type CPlayer_GetLastPlayedTimes_Request struct { + MinLastPlayed *uint32 `protobuf:"varint,1,opt,name=min_last_played" json:"min_last_played,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_GetLastPlayedTimes_Request) Reset() { *m = CPlayer_GetLastPlayedTimes_Request{} } +func (m *CPlayer_GetLastPlayedTimes_Request) String() string { return proto.CompactTextString(m) } +func (*CPlayer_GetLastPlayedTimes_Request) ProtoMessage() {} +func (*CPlayer_GetLastPlayedTimes_Request) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{2} +} + +func (m *CPlayer_GetLastPlayedTimes_Request) GetMinLastPlayed() uint32 { + if m != nil && m.MinLastPlayed != nil { + return *m.MinLastPlayed + } + return 0 +} + +type CPlayer_GetLastPlayedTimes_Response struct { + Games []*CPlayer_GetLastPlayedTimes_Response_Game `protobuf:"bytes,1,rep,name=games" json:"games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_GetLastPlayedTimes_Response) Reset() { *m = CPlayer_GetLastPlayedTimes_Response{} } +func (m *CPlayer_GetLastPlayedTimes_Response) String() string { return proto.CompactTextString(m) } +func (*CPlayer_GetLastPlayedTimes_Response) ProtoMessage() {} +func (*CPlayer_GetLastPlayedTimes_Response) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{3} +} + +func (m *CPlayer_GetLastPlayedTimes_Response) GetGames() []*CPlayer_GetLastPlayedTimes_Response_Game { + if m != nil { + return m.Games + } + return nil +} + +type CPlayer_GetLastPlayedTimes_Response_Game struct { + Appid *int32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + LastPlaytime *uint32 `protobuf:"varint,2,opt,name=last_playtime" json:"last_playtime,omitempty"` + Playtime_2Weeks *int32 `protobuf:"varint,3,opt,name=playtime_2weeks" json:"playtime_2weeks,omitempty"` + PlaytimeForever *int32 `protobuf:"varint,4,opt,name=playtime_forever" json:"playtime_forever,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_GetLastPlayedTimes_Response_Game) Reset() { + *m = CPlayer_GetLastPlayedTimes_Response_Game{} +} +func (m *CPlayer_GetLastPlayedTimes_Response_Game) String() string { return proto.CompactTextString(m) } +func (*CPlayer_GetLastPlayedTimes_Response_Game) ProtoMessage() {} +func (*CPlayer_GetLastPlayedTimes_Response_Game) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{3, 0} +} + +func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetAppid() int32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetLastPlaytime() uint32 { + if m != nil && m.LastPlaytime != nil { + return *m.LastPlaytime + } + return 0 +} + +func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetPlaytime_2Weeks() int32 { + if m != nil && m.Playtime_2Weeks != nil { + return *m.Playtime_2Weeks + } + return 0 +} + +func (m *CPlayer_GetLastPlayedTimes_Response_Game) GetPlaytimeForever() int32 { + if m != nil && m.PlaytimeForever != nil { + return *m.PlaytimeForever + } + return 0 +} + +type CPlayer_AcceptSSA_Request struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_AcceptSSA_Request) Reset() { *m = CPlayer_AcceptSSA_Request{} } +func (m *CPlayer_AcceptSSA_Request) String() string { return proto.CompactTextString(m) } +func (*CPlayer_AcceptSSA_Request) ProtoMessage() {} +func (*CPlayer_AcceptSSA_Request) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{4} } + +type CPlayer_AcceptSSA_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_AcceptSSA_Response) Reset() { *m = CPlayer_AcceptSSA_Response{} } +func (m *CPlayer_AcceptSSA_Response) String() string { return proto.CompactTextString(m) } +func (*CPlayer_AcceptSSA_Response) ProtoMessage() {} +func (*CPlayer_AcceptSSA_Response) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{5} } + +type CPlayer_LastPlayedTimes_Notification struct { + Games []*CPlayer_GetLastPlayedTimes_Response_Game `protobuf:"bytes,1,rep,name=games" json:"games,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayer_LastPlayedTimes_Notification) Reset() { *m = CPlayer_LastPlayedTimes_Notification{} } +func (m *CPlayer_LastPlayedTimes_Notification) String() string { return proto.CompactTextString(m) } +func (*CPlayer_LastPlayedTimes_Notification) ProtoMessage() {} +func (*CPlayer_LastPlayedTimes_Notification) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{6} +} + +func (m *CPlayer_LastPlayedTimes_Notification) GetGames() []*CPlayer_GetLastPlayedTimes_Response_Game { + if m != nil { + return m.Games + } + return nil +} + +type CPlayerClient_GetSystemInformation_Request struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayerClient_GetSystemInformation_Request) Reset() { + *m = CPlayerClient_GetSystemInformation_Request{} +} +func (m *CPlayerClient_GetSystemInformation_Request) String() string { + return proto.CompactTextString(m) +} +func (*CPlayerClient_GetSystemInformation_Request) ProtoMessage() {} +func (*CPlayerClient_GetSystemInformation_Request) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{7} +} + +type CClientSystemInfo struct { + Cpu *CClientSystemInfo_CPU `protobuf:"bytes,1,opt,name=cpu" json:"cpu,omitempty"` + VideoCard *CClientSystemInfo_VideoCard `protobuf:"bytes,2,opt,name=video_card" json:"video_card,omitempty"` + OperatingSystem *string `protobuf:"bytes,3,opt,name=operating_system" json:"operating_system,omitempty"` + Os_64Bit *bool `protobuf:"varint,4,opt,name=os_64bit" json:"os_64bit,omitempty"` + SystemRamMb *int32 `protobuf:"varint,5,opt,name=system_ram_mb" json:"system_ram_mb,omitempty"` + AudioDevice *string `protobuf:"bytes,6,opt,name=audio_device" json:"audio_device,omitempty"` + AudioDriverVersion *string `protobuf:"bytes,7,opt,name=audio_driver_version" json:"audio_driver_version,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CClientSystemInfo) Reset() { *m = CClientSystemInfo{} } +func (m *CClientSystemInfo) String() string { return proto.CompactTextString(m) } +func (*CClientSystemInfo) ProtoMessage() {} +func (*CClientSystemInfo) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{8} } + +func (m *CClientSystemInfo) GetCpu() *CClientSystemInfo_CPU { + if m != nil { + return m.Cpu + } + return nil +} + +func (m *CClientSystemInfo) GetVideoCard() *CClientSystemInfo_VideoCard { + if m != nil { + return m.VideoCard + } + return nil +} + +func (m *CClientSystemInfo) GetOperatingSystem() string { + if m != nil && m.OperatingSystem != nil { + return *m.OperatingSystem + } + return "" +} + +func (m *CClientSystemInfo) GetOs_64Bit() bool { + if m != nil && m.Os_64Bit != nil { + return *m.Os_64Bit + } + return false +} + +func (m *CClientSystemInfo) GetSystemRamMb() int32 { + if m != nil && m.SystemRamMb != nil { + return *m.SystemRamMb + } + return 0 +} + +func (m *CClientSystemInfo) GetAudioDevice() string { + if m != nil && m.AudioDevice != nil { + return *m.AudioDevice + } + return "" +} + +func (m *CClientSystemInfo) GetAudioDriverVersion() string { + if m != nil && m.AudioDriverVersion != nil { + return *m.AudioDriverVersion + } + return "" +} + +type CClientSystemInfo_CPU struct { + SpeedMhz *int32 `protobuf:"varint,1,opt,name=speed_mhz" json:"speed_mhz,omitempty"` + Vendor *string `protobuf:"bytes,2,opt,name=vendor" json:"vendor,omitempty"` + LogicalProcessors *int32 `protobuf:"varint,3,opt,name=logical_processors" json:"logical_processors,omitempty"` + PhysicalProcessors *int32 `protobuf:"varint,4,opt,name=physical_processors" json:"physical_processors,omitempty"` + Hyperthreading *bool `protobuf:"varint,5,opt,name=hyperthreading" json:"hyperthreading,omitempty"` + Fcmov *bool `protobuf:"varint,6,opt,name=fcmov" json:"fcmov,omitempty"` + Sse2 *bool `protobuf:"varint,7,opt,name=sse2" json:"sse2,omitempty"` + Sse3 *bool `protobuf:"varint,8,opt,name=sse3" json:"sse3,omitempty"` + Ssse3 *bool `protobuf:"varint,9,opt,name=ssse3" json:"ssse3,omitempty"` + Sse4A *bool `protobuf:"varint,10,opt,name=sse4a" json:"sse4a,omitempty"` + Sse41 *bool `protobuf:"varint,11,opt,name=sse41" json:"sse41,omitempty"` + Sse42 *bool `protobuf:"varint,12,opt,name=sse42" json:"sse42,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CClientSystemInfo_CPU) Reset() { *m = CClientSystemInfo_CPU{} } +func (m *CClientSystemInfo_CPU) String() string { return proto.CompactTextString(m) } +func (*CClientSystemInfo_CPU) ProtoMessage() {} +func (*CClientSystemInfo_CPU) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{8, 0} } + +func (m *CClientSystemInfo_CPU) GetSpeedMhz() int32 { + if m != nil && m.SpeedMhz != nil { + return *m.SpeedMhz + } + return 0 +} + +func (m *CClientSystemInfo_CPU) GetVendor() string { + if m != nil && m.Vendor != nil { + return *m.Vendor + } + return "" +} + +func (m *CClientSystemInfo_CPU) GetLogicalProcessors() int32 { + if m != nil && m.LogicalProcessors != nil { + return *m.LogicalProcessors + } + return 0 +} + +func (m *CClientSystemInfo_CPU) GetPhysicalProcessors() int32 { + if m != nil && m.PhysicalProcessors != nil { + return *m.PhysicalProcessors + } + return 0 +} + +func (m *CClientSystemInfo_CPU) GetHyperthreading() bool { + if m != nil && m.Hyperthreading != nil { + return *m.Hyperthreading + } + return false +} + +func (m *CClientSystemInfo_CPU) GetFcmov() bool { + if m != nil && m.Fcmov != nil { + return *m.Fcmov + } + return false +} + +func (m *CClientSystemInfo_CPU) GetSse2() bool { + if m != nil && m.Sse2 != nil { + return *m.Sse2 + } + return false +} + +func (m *CClientSystemInfo_CPU) GetSse3() bool { + if m != nil && m.Sse3 != nil { + return *m.Sse3 + } + return false +} + +func (m *CClientSystemInfo_CPU) GetSsse3() bool { + if m != nil && m.Ssse3 != nil { + return *m.Ssse3 + } + return false +} + +func (m *CClientSystemInfo_CPU) GetSse4A() bool { + if m != nil && m.Sse4A != nil { + return *m.Sse4A + } + return false +} + +func (m *CClientSystemInfo_CPU) GetSse41() bool { + if m != nil && m.Sse41 != nil { + return *m.Sse41 + } + return false +} + +func (m *CClientSystemInfo_CPU) GetSse42() bool { + if m != nil && m.Sse42 != nil { + return *m.Sse42 + } + return false +} + +type CClientSystemInfo_VideoCard struct { + Driver *string `protobuf:"bytes,1,opt,name=driver" json:"driver,omitempty"` + DriverVersion *string `protobuf:"bytes,2,opt,name=driver_version" json:"driver_version,omitempty"` + DriverDate *uint32 `protobuf:"varint,3,opt,name=driver_date" json:"driver_date,omitempty"` + DirectxVersion *string `protobuf:"bytes,4,opt,name=directx_version" json:"directx_version,omitempty"` + OpenglVersion *string `protobuf:"bytes,5,opt,name=opengl_version" json:"opengl_version,omitempty"` + Vendorid *int32 `protobuf:"varint,6,opt,name=vendorid" json:"vendorid,omitempty"` + Deviceid *int32 `protobuf:"varint,7,opt,name=deviceid" json:"deviceid,omitempty"` + VramMb *int32 `protobuf:"varint,8,opt,name=vram_mb" json:"vram_mb,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CClientSystemInfo_VideoCard) Reset() { *m = CClientSystemInfo_VideoCard{} } +func (m *CClientSystemInfo_VideoCard) String() string { return proto.CompactTextString(m) } +func (*CClientSystemInfo_VideoCard) ProtoMessage() {} +func (*CClientSystemInfo_VideoCard) Descriptor() ([]byte, []int) { return player_fileDescriptor0, []int{8, 1} } + +func (m *CClientSystemInfo_VideoCard) GetDriver() string { + if m != nil && m.Driver != nil { + return *m.Driver + } + return "" +} + +func (m *CClientSystemInfo_VideoCard) GetDriverVersion() string { + if m != nil && m.DriverVersion != nil { + return *m.DriverVersion + } + return "" +} + +func (m *CClientSystemInfo_VideoCard) GetDriverDate() uint32 { + if m != nil && m.DriverDate != nil { + return *m.DriverDate + } + return 0 +} + +func (m *CClientSystemInfo_VideoCard) GetDirectxVersion() string { + if m != nil && m.DirectxVersion != nil { + return *m.DirectxVersion + } + return "" +} + +func (m *CClientSystemInfo_VideoCard) GetOpenglVersion() string { + if m != nil && m.OpenglVersion != nil { + return *m.OpenglVersion + } + return "" +} + +func (m *CClientSystemInfo_VideoCard) GetVendorid() int32 { + if m != nil && m.Vendorid != nil { + return *m.Vendorid + } + return 0 +} + +func (m *CClientSystemInfo_VideoCard) GetDeviceid() int32 { + if m != nil && m.Deviceid != nil { + return *m.Deviceid + } + return 0 +} + +func (m *CClientSystemInfo_VideoCard) GetVramMb() int32 { + if m != nil && m.VramMb != nil { + return *m.VramMb + } + return 0 +} + +type CPlayerClient_GetSystemInformation_Response struct { + SystemInfo *CClientSystemInfo `protobuf:"bytes,1,opt,name=system_info" json:"system_info,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPlayerClient_GetSystemInformation_Response) Reset() { + *m = CPlayerClient_GetSystemInformation_Response{} +} +func (m *CPlayerClient_GetSystemInformation_Response) String() string { + return proto.CompactTextString(m) +} +func (*CPlayerClient_GetSystemInformation_Response) ProtoMessage() {} +func (*CPlayerClient_GetSystemInformation_Response) Descriptor() ([]byte, []int) { + return player_fileDescriptor0, []int{9} +} + +func (m *CPlayerClient_GetSystemInformation_Response) GetSystemInfo() *CClientSystemInfo { + if m != nil { + return m.SystemInfo + } + return nil +} + +func init() { + proto.RegisterType((*CPlayer_GetGameBadgeLevels_Request)(nil), "CPlayer_GetGameBadgeLevels_Request") + proto.RegisterType((*CPlayer_GetGameBadgeLevels_Response)(nil), "CPlayer_GetGameBadgeLevels_Response") + proto.RegisterType((*CPlayer_GetGameBadgeLevels_Response_Badge)(nil), "CPlayer_GetGameBadgeLevels_Response.Badge") + proto.RegisterType((*CPlayer_GetLastPlayedTimes_Request)(nil), "CPlayer_GetLastPlayedTimes_Request") + proto.RegisterType((*CPlayer_GetLastPlayedTimes_Response)(nil), "CPlayer_GetLastPlayedTimes_Response") + proto.RegisterType((*CPlayer_GetLastPlayedTimes_Response_Game)(nil), "CPlayer_GetLastPlayedTimes_Response.Game") + proto.RegisterType((*CPlayer_AcceptSSA_Request)(nil), "CPlayer_AcceptSSA_Request") + proto.RegisterType((*CPlayer_AcceptSSA_Response)(nil), "CPlayer_AcceptSSA_Response") + proto.RegisterType((*CPlayer_LastPlayedTimes_Notification)(nil), "CPlayer_LastPlayedTimes_Notification") + proto.RegisterType((*CPlayerClient_GetSystemInformation_Request)(nil), "CPlayerClient_GetSystemInformation_Request") + proto.RegisterType((*CClientSystemInfo)(nil), "CClientSystemInfo") + proto.RegisterType((*CClientSystemInfo_CPU)(nil), "CClientSystemInfo.CPU") + proto.RegisterType((*CClientSystemInfo_VideoCard)(nil), "CClientSystemInfo.VideoCard") + proto.RegisterType((*CPlayerClient_GetSystemInformation_Response)(nil), "CPlayerClient_GetSystemInformation_Response") +} + +var player_fileDescriptor0 = []byte{ + // 1067 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x9c, 0x55, 0x4d, 0x6f, 0xdb, 0x46, + 0x10, 0x05, 0x2d, 0xcb, 0x96, 0x46, 0x76, 0x9c, 0x6c, 0x9c, 0x94, 0xa1, 0x5d, 0x60, 0x41, 0xa7, + 0xf9, 0x70, 0x1c, 0xa2, 0x55, 0x82, 0xa2, 0x68, 0x0b, 0x04, 0xb6, 0x0f, 0x41, 0x01, 0x23, 0x48, + 0xe3, 0x38, 0xa7, 0x02, 0xec, 0x8a, 0x5c, 0xc9, 0x44, 0x48, 0xae, 0xca, 0x5d, 0x29, 0x55, 0x4f, + 0x45, 0xce, 0xbd, 0x15, 0xfd, 0x1b, 0xbd, 0xb9, 0xe7, 0x00, 0xfd, 0x23, 0xfd, 0x03, 0x3d, 0xf6, + 0xde, 0xd9, 0x5d, 0x52, 0x1f, 0x96, 0x9d, 0xaa, 0x39, 0x18, 0xd6, 0xee, 0xbc, 0x1d, 0xbe, 0x79, + 0x3b, 0xf3, 0x16, 0xee, 0x48, 0xc5, 0x59, 0x96, 0x71, 0x29, 0x59, 0x8f, 0xcb, 0xb0, 0x9f, 0xb2, + 0x11, 0x2f, 0x02, 0xb3, 0x19, 0xa5, 0x09, 0xcf, 0x55, 0xd0, 0x2f, 0x84, 0x12, 0xde, 0xde, 0x2c, + 0x6e, 0x90, 0x27, 0xdd, 0x84, 0xc7, 0x61, 0x87, 0x49, 0x3e, 0x8f, 0xf6, 0x1f, 0x81, 0x7f, 0xf8, + 0xdc, 0xa4, 0x0a, 0x9f, 0x72, 0xf5, 0x94, 0x65, 0xfc, 0x80, 0xc5, 0x3d, 0x7e, 0xc4, 0x87, 0x3c, + 0x95, 0xe1, 0x0b, 0xfe, 0xc3, 0x80, 0x4b, 0x45, 0xd6, 0xa1, 0xce, 0xfa, 0xfd, 0x24, 0x76, 0x1d, + 0xea, 0xdc, 0x5b, 0xf7, 0xcf, 0x1c, 0xd8, 0x79, 0xef, 0x29, 0xd9, 0x17, 0xb9, 0xe4, 0x64, 0x13, + 0xd6, 0x2c, 0xcd, 0x30, 0xd5, 0x11, 0x7b, 0x9a, 0x7c, 0x09, 0x2b, 0x1d, 0x8d, 0x96, 0xee, 0x12, + 0xad, 0xdd, 0x6b, 0xb5, 0x77, 0x83, 0x05, 0x72, 0x05, 0x66, 0xd3, 0xfb, 0x1a, 0xea, 0xe6, 0x87, + 0x66, 0x34, 0xc9, 0x59, 0x27, 0x57, 0x60, 0x45, 0xf2, 0x22, 0x31, 0x39, 0xf5, 0x1a, 0xbf, 0xdc, + 0x11, 0x45, 0x8c, 0x39, 0x23, 0x91, 0x8a, 0xc2, 0xad, 0x19, 0xde, 0x6f, 0x9d, 0x99, 0x6a, 0x8f, + 0x98, 0x54, 0x66, 0x15, 0xbf, 0x4c, 0x50, 0xaf, 0x71, 0xb5, 0xdf, 0xc1, 0x46, 0x96, 0xe4, 0x61, + 0x8a, 0x61, 0x2b, 0x73, 0x59, 0xf7, 0xc1, 0xe1, 0xdb, 0x33, 0xf7, 0xc9, 0xcb, 0x53, 0x4e, 0x33, + 0x21, 0x15, 0x2d, 0x78, 0x84, 0x3a, 0x52, 0x0d, 0x7b, 0x68, 0x61, 0x54, 0x61, 0x1e, 0xaa, 0x10, + 0x60, 0x35, 0xa6, 0x2c, 0x2d, 0x38, 0x8b, 0x47, 0xf4, 0x75, 0x2e, 0xde, 0x48, 0xca, 0x3a, 0x62, + 0xa0, 0xfc, 0x77, 0xb3, 0xe2, 0xcd, 0x93, 0x28, 0xc5, 0xfb, 0x02, 0xea, 0x3d, 0x14, 0x43, 0xe2, + 0xb7, 0xb5, 0x4a, 0xf7, 0x83, 0x05, 0x0e, 0x05, 0x5a, 0x3e, 0x2f, 0x84, 0x65, 0xfd, 0x7f, 0xf6, + 0xd6, 0xea, 0xe4, 0x06, 0xac, 0x8f, 0x4b, 0xd2, 0x44, 0x8d, 0x54, 0xeb, 0xe4, 0x23, 0xd8, 0xa8, + 0x76, 0xc2, 0xf6, 0x1b, 0xce, 0x5f, 0x4b, 0xa3, 0x56, 0x9d, 0xb8, 0x70, 0x75, 0x1c, 0xe8, 0x8a, + 0x02, 0xd5, 0x2e, 0xdc, 0x65, 0x1d, 0xf1, 0xb7, 0xe0, 0x56, 0x45, 0x66, 0x3f, 0x8a, 0x78, 0x5f, + 0x1d, 0x1f, 0xef, 0x57, 0xea, 0xf9, 0xdb, 0xe0, 0x5d, 0x14, 0xb4, 0x04, 0xfd, 0xef, 0xe1, 0x76, + 0x15, 0x3d, 0x5f, 0xc4, 0x33, 0xa1, 0xb0, 0x55, 0x23, 0xa6, 0x12, 0x91, 0x7f, 0x78, 0xf5, 0xfe, + 0x1e, 0xec, 0x96, 0xd8, 0x43, 0x73, 0x09, 0xfa, 0xc4, 0xf1, 0x08, 0x3b, 0x3f, 0xfb, 0x26, 0xc7, + 0x32, 0x32, 0x93, 0x7f, 0xcc, 0xf6, 0x9f, 0x65, 0xb8, 0x76, 0x68, 0x81, 0x13, 0x10, 0xd9, 0x81, + 0x5a, 0xd4, 0x1f, 0x18, 0xdd, 0x5a, 0xed, 0x9b, 0xc1, 0x1c, 0x00, 0xd9, 0x9c, 0x90, 0x4f, 0x01, + 0x86, 0x49, 0xcc, 0x45, 0x18, 0xb1, 0x22, 0x36, 0x62, 0xb6, 0xda, 0xdb, 0x17, 0x60, 0x5f, 0x69, + 0xd0, 0x21, 0x62, 0xb4, 0xa2, 0xa2, 0xcf, 0x0b, 0x64, 0x90, 0xf7, 0x42, 0x69, 0x10, 0x46, 0xeb, + 0x26, 0xb9, 0x0a, 0x0d, 0x21, 0xc3, 0xcf, 0x1f, 0x77, 0x12, 0x65, 0x34, 0x6e, 0xe8, 0xdb, 0xb2, + 0x88, 0xb0, 0x60, 0x59, 0x98, 0x75, 0xdc, 0x7a, 0xd5, 0xd8, 0x6c, 0x10, 0x27, 0x22, 0x8c, 0xf9, + 0x30, 0x89, 0xb8, 0xbb, 0x62, 0x8e, 0x6f, 0xc3, 0x66, 0xb9, 0x5b, 0x24, 0x78, 0x4d, 0x21, 0xfe, + 0x49, 0xac, 0xd2, 0x5d, 0xd5, 0x51, 0xef, 0x2f, 0x07, 0x6a, 0x9a, 0xf0, 0x35, 0x68, 0xca, 0x3e, + 0x47, 0x2f, 0xc8, 0x4e, 0x7f, 0x9a, 0xcc, 0xcd, 0x90, 0xe7, 0x31, 0x4e, 0xc8, 0x92, 0x49, 0xe4, + 0x01, 0x49, 0x45, 0x0f, 0x2f, 0x21, 0x0d, 0xd1, 0x1f, 0x22, 0x34, 0x11, 0x51, 0x54, 0xfd, 0xb0, + 0x05, 0xd7, 0xfb, 0xa7, 0x23, 0x79, 0x3e, 0x68, 0x5a, 0x82, 0xdc, 0x84, 0x2b, 0xa7, 0x23, 0xac, + 0x4d, 0x9d, 0xea, 0x8e, 0xc7, 0xfa, 0x0c, 0xdf, 0x86, 0xee, 0xc1, 0x6e, 0x94, 0x89, 0xa1, 0x21, + 0xda, 0x20, 0x6b, 0xb0, 0x2c, 0x25, 0x6f, 0x1b, 0x62, 0xd5, 0xea, 0x91, 0xdb, 0xa8, 0xa0, 0xd2, + 0x2c, 0x9b, 0x93, 0x25, 0x7f, 0xcc, 0x5c, 0x98, 0x5e, 0x7e, 0xe6, 0xb6, 0xa6, 0x97, 0x6d, 0x77, + 0x4d, 0x2f, 0xbd, 0xdf, 0x1d, 0x68, 0x4e, 0x74, 0xc6, 0xaa, 0xac, 0x10, 0xa6, 0xca, 0xa6, 0x26, + 0x77, 0x4e, 0x18, 0x5b, 0xed, 0x75, 0x68, 0x95, 0xfb, 0x31, 0x53, 0xdc, 0x9a, 0x84, 0x9e, 0x87, + 0x38, 0xc1, 0xd9, 0x56, 0x3f, 0x8e, 0xd1, 0xcb, 0x55, 0x16, 0xbc, 0xbd, 0xbc, 0x97, 0x8e, 0xf7, + 0xeb, 0xd5, 0xdd, 0x59, 0x0d, 0x71, 0xd2, 0x56, 0x8c, 0x18, 0xb8, 0x63, 0xaf, 0x07, 0x77, 0x56, + 0xcd, 0xce, 0x06, 0xac, 0x0e, 0xcb, 0x7b, 0x6c, 0x98, 0x11, 0x7a, 0x05, 0x0f, 0x16, 0xea, 0xd2, + 0xd2, 0x0c, 0xee, 0x42, 0xab, 0xec, 0x86, 0x04, 0xc3, 0x65, 0x63, 0x92, 0xf9, 0x66, 0x6b, 0xff, + 0x5d, 0x83, 0x15, 0x9b, 0x97, 0xfc, 0xe1, 0x00, 0x99, 0x77, 0x54, 0xb2, 0x13, 0xfc, 0xb7, 0xe1, + 0x7b, 0xb7, 0x17, 0xf1, 0x64, 0xff, 0x04, 0xfd, 0xf0, 0xdb, 0x17, 0x5c, 0x0d, 0x8a, 0x5c, 0x1a, + 0xdb, 0x3b, 0xd6, 0xef, 0x0b, 0x35, 0x30, 0x2a, 0xba, 0x94, 0xd1, 0x01, 0xba, 0xf2, 0x9e, 0x09, + 0x99, 0x04, 0xd4, 0x78, 0x36, 0xc5, 0x02, 0xcd, 0x9e, 0x9e, 0xf0, 0x3d, 0xca, 0xf2, 0x98, 0x26, + 0x5d, 0x9a, 0xa8, 0xbb, 0x12, 0x23, 0x49, 0x4a, 0x7e, 0x73, 0xc0, 0xb5, 0x85, 0xcd, 0x0f, 0xfb, + 0x2c, 0xfd, 0x4b, 0x1c, 0x7c, 0x96, 0xfe, 0x65, 0x76, 0xe1, 0x07, 0x48, 0x7f, 0x17, 0x01, 0x96, + 0xfb, 0x79, 0x1f, 0x97, 0x63, 0x9a, 0x2c, 0x8a, 0xc4, 0x20, 0x57, 0x24, 0x82, 0xe6, 0xd8, 0xd1, + 0x88, 0x17, 0x5c, 0x6a, 0x81, 0xde, 0x56, 0xf0, 0x1e, 0x07, 0xfc, 0x18, 0xbf, 0x7a, 0xeb, 0x04, + 0x75, 0xa1, 0x89, 0xd4, 0xa9, 0x31, 0x8e, 0xe3, 0x62, 0xe5, 0x3b, 0xde, 0xf7, 0x1e, 0x62, 0xf8, + 0xfe, 0x3e, 0xc5, 0xb8, 0x6e, 0x20, 0xc3, 0x41, 0x83, 0xa4, 0xd4, 0x20, 0xab, 0xaf, 0x7d, 0x53, + 0x29, 0xf6, 0x2c, 0x6b, 0xff, 0x5a, 0x83, 0xb5, 0xe9, 0x3e, 0x22, 0xbf, 0x38, 0x70, 0xc3, 0x38, + 0xe9, 0xe8, 0xbc, 0x72, 0x9f, 0x04, 0x8b, 0x38, 0xaf, 0xd7, 0x0a, 0x9e, 0x89, 0x31, 0xd9, 0x27, + 0xc8, 0xe6, 0xab, 0xe9, 0x30, 0xed, 0x16, 0x22, 0x33, 0xec, 0x90, 0x81, 0x12, 0xd5, 0x43, 0x87, + 0x97, 0x9d, 0xe1, 0x13, 0x51, 0xbd, 0x89, 0x9a, 0xa1, 0x11, 0x91, 0xfc, 0xe9, 0xc0, 0xe6, 0x45, + 0xad, 0x4d, 0x1e, 0x04, 0x8b, 0xbb, 0xb4, 0xb7, 0x17, 0xfc, 0x8f, 0x61, 0xf1, 0x9f, 0x23, 0xe9, + 0xa3, 0xf2, 0xa8, 0xe5, 0xab, 0xc5, 0x9d, 0x70, 0x9e, 0x7a, 0xa0, 0xb5, 0xbc, 0xc9, 0x24, 0x87, + 0x7d, 0xa2, 0x0d, 0x40, 0x77, 0xae, 0xa4, 0x76, 0xe8, 0x3c, 0xdd, 0x29, 0x77, 0xe6, 0xc4, 0xaf, + 0x92, 0xe4, 0x53, 0xfa, 0xc8, 0x77, 0x67, 0xee, 0xd2, 0x41, 0xed, 0x67, 0xc7, 0xf9, 0x37, 0x00, + 0x00, 0xff, 0xff, 0x9e, 0xe2, 0xe2, 0x67, 0xb1, 0x09, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/publishedfile.pb.go b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/publishedfile.pb.go new file mode 100644 index 00000000..06e85481 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/protobuf/unified/publishedfile.pb.go @@ -0,0 +1,2702 @@ +// Code generated by protoc-gen-go. +// source: steammessages_publishedfile.steamclient.proto +// DO NOT EDIT! + +package unified + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type PublishedFileDetails_EPublishedFileForSaleStatus int32 + +const ( + PublishedFileDetails_k_PFFSS_NotForSale PublishedFileDetails_EPublishedFileForSaleStatus = 0 + PublishedFileDetails_k_PFFSS_PendingApproval PublishedFileDetails_EPublishedFileForSaleStatus = 1 + PublishedFileDetails_k_PFFSS_ApprovedForSale PublishedFileDetails_EPublishedFileForSaleStatus = 2 + PublishedFileDetails_k_PFFSS_RejectedForSale PublishedFileDetails_EPublishedFileForSaleStatus = 3 + PublishedFileDetails_k_PFFSS_NoLongerForSale PublishedFileDetails_EPublishedFileForSaleStatus = 4 + PublishedFileDetails_k_PFFSS_TentativeApproval PublishedFileDetails_EPublishedFileForSaleStatus = 5 +) + +var PublishedFileDetails_EPublishedFileForSaleStatus_name = map[int32]string{ + 0: "k_PFFSS_NotForSale", + 1: "k_PFFSS_PendingApproval", + 2: "k_PFFSS_ApprovedForSale", + 3: "k_PFFSS_RejectedForSale", + 4: "k_PFFSS_NoLongerForSale", + 5: "k_PFFSS_TentativeApproval", +} +var PublishedFileDetails_EPublishedFileForSaleStatus_value = map[string]int32{ + "k_PFFSS_NotForSale": 0, + "k_PFFSS_PendingApproval": 1, + "k_PFFSS_ApprovedForSale": 2, + "k_PFFSS_RejectedForSale": 3, + "k_PFFSS_NoLongerForSale": 4, + "k_PFFSS_TentativeApproval": 5, +} + +func (x PublishedFileDetails_EPublishedFileForSaleStatus) Enum() *PublishedFileDetails_EPublishedFileForSaleStatus { + p := new(PublishedFileDetails_EPublishedFileForSaleStatus) + *p = x + return p +} +func (x PublishedFileDetails_EPublishedFileForSaleStatus) String() string { + return proto.EnumName(PublishedFileDetails_EPublishedFileForSaleStatus_name, int32(x)) +} +func (x *PublishedFileDetails_EPublishedFileForSaleStatus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PublishedFileDetails_EPublishedFileForSaleStatus_value, data, "PublishedFileDetails_EPublishedFileForSaleStatus") + if err != nil { + return err + } + *x = PublishedFileDetails_EPublishedFileForSaleStatus(value) + return nil +} +func (PublishedFileDetails_EPublishedFileForSaleStatus) EnumDescriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{9, 0} +} + +type CPublishedFile_Subscribe_Request struct { + Publishedfileid *uint64 `protobuf:"varint,1,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + ListType *uint32 `protobuf:"varint,2,opt,name=list_type" json:"list_type,omitempty"` + Appid *int32 `protobuf:"varint,3,opt,name=appid" json:"appid,omitempty"` + NotifyClient *bool `protobuf:"varint,4,opt,name=notify_client" json:"notify_client,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Subscribe_Request) Reset() { *m = CPublishedFile_Subscribe_Request{} } +func (m *CPublishedFile_Subscribe_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Subscribe_Request) ProtoMessage() {} +func (*CPublishedFile_Subscribe_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{0} +} + +func (m *CPublishedFile_Subscribe_Request) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *CPublishedFile_Subscribe_Request) GetListType() uint32 { + if m != nil && m.ListType != nil { + return *m.ListType + } + return 0 +} + +func (m *CPublishedFile_Subscribe_Request) GetAppid() int32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_Subscribe_Request) GetNotifyClient() bool { + if m != nil && m.NotifyClient != nil { + return *m.NotifyClient + } + return false +} + +type CPublishedFile_Subscribe_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Subscribe_Response) Reset() { *m = CPublishedFile_Subscribe_Response{} } +func (m *CPublishedFile_Subscribe_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Subscribe_Response) ProtoMessage() {} +func (*CPublishedFile_Subscribe_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{1} +} + +type CPublishedFile_Unsubscribe_Request struct { + Publishedfileid *uint64 `protobuf:"varint,1,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + ListType *uint32 `protobuf:"varint,2,opt,name=list_type" json:"list_type,omitempty"` + Appid *int32 `protobuf:"varint,3,opt,name=appid" json:"appid,omitempty"` + NotifyClient *bool `protobuf:"varint,4,opt,name=notify_client" json:"notify_client,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Unsubscribe_Request) Reset() { *m = CPublishedFile_Unsubscribe_Request{} } +func (m *CPublishedFile_Unsubscribe_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Unsubscribe_Request) ProtoMessage() {} +func (*CPublishedFile_Unsubscribe_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{2} +} + +func (m *CPublishedFile_Unsubscribe_Request) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *CPublishedFile_Unsubscribe_Request) GetListType() uint32 { + if m != nil && m.ListType != nil { + return *m.ListType + } + return 0 +} + +func (m *CPublishedFile_Unsubscribe_Request) GetAppid() int32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_Unsubscribe_Request) GetNotifyClient() bool { + if m != nil && m.NotifyClient != nil { + return *m.NotifyClient + } + return false +} + +type CPublishedFile_Unsubscribe_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Unsubscribe_Response) Reset() { *m = CPublishedFile_Unsubscribe_Response{} } +func (m *CPublishedFile_Unsubscribe_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Unsubscribe_Response) ProtoMessage() {} +func (*CPublishedFile_Unsubscribe_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{3} +} + +type CPublishedFile_CanSubscribe_Request struct { + Publishedfileid *uint64 `protobuf:"varint,1,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_CanSubscribe_Request) Reset() { *m = CPublishedFile_CanSubscribe_Request{} } +func (m *CPublishedFile_CanSubscribe_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_CanSubscribe_Request) ProtoMessage() {} +func (*CPublishedFile_CanSubscribe_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{4} +} + +func (m *CPublishedFile_CanSubscribe_Request) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +type CPublishedFile_CanSubscribe_Response struct { + CanSubscribe *bool `protobuf:"varint,1,opt,name=can_subscribe" json:"can_subscribe,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_CanSubscribe_Response) Reset() { *m = CPublishedFile_CanSubscribe_Response{} } +func (m *CPublishedFile_CanSubscribe_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_CanSubscribe_Response) ProtoMessage() {} +func (*CPublishedFile_CanSubscribe_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{5} +} + +func (m *CPublishedFile_CanSubscribe_Response) GetCanSubscribe() bool { + if m != nil && m.CanSubscribe != nil { + return *m.CanSubscribe + } + return false +} + +type CPublishedFile_Publish_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + ConsumerAppid *uint32 `protobuf:"varint,2,opt,name=consumer_appid" json:"consumer_appid,omitempty"` + Cloudfilename *string `protobuf:"bytes,3,opt,name=cloudfilename" json:"cloudfilename,omitempty"` + PreviewCloudfilename *string `protobuf:"bytes,4,opt,name=preview_cloudfilename" json:"preview_cloudfilename,omitempty"` + Title *string `protobuf:"bytes,5,opt,name=title" json:"title,omitempty"` + FileDescription *string `protobuf:"bytes,6,opt,name=file_description" json:"file_description,omitempty"` + FileType *uint32 `protobuf:"varint,7,opt,name=file_type" json:"file_type,omitempty"` + ConsumerShortcutName *string `protobuf:"bytes,8,opt,name=consumer_shortcut_name" json:"consumer_shortcut_name,omitempty"` + YoutubeUsername *string `protobuf:"bytes,9,opt,name=youtube_username" json:"youtube_username,omitempty"` + YoutubeVideoid *string `protobuf:"bytes,10,opt,name=youtube_videoid" json:"youtube_videoid,omitempty"` + Visibility *uint32 `protobuf:"varint,11,opt,name=visibility" json:"visibility,omitempty"` + RedirectUri *string `protobuf:"bytes,12,opt,name=redirect_uri" json:"redirect_uri,omitempty"` + Tags []string `protobuf:"bytes,13,rep,name=tags" json:"tags,omitempty"` + CollectionType *string `protobuf:"bytes,14,opt,name=collection_type" json:"collection_type,omitempty"` + GameType *string `protobuf:"bytes,15,opt,name=game_type" json:"game_type,omitempty"` + Url *string `protobuf:"bytes,16,opt,name=url" json:"url,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Publish_Request) Reset() { *m = CPublishedFile_Publish_Request{} } +func (m *CPublishedFile_Publish_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Publish_Request) ProtoMessage() {} +func (*CPublishedFile_Publish_Request) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{6} } + +func (m *CPublishedFile_Publish_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_Publish_Request) GetConsumerAppid() uint32 { + if m != nil && m.ConsumerAppid != nil { + return *m.ConsumerAppid + } + return 0 +} + +func (m *CPublishedFile_Publish_Request) GetCloudfilename() string { + if m != nil && m.Cloudfilename != nil { + return *m.Cloudfilename + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetPreviewCloudfilename() string { + if m != nil && m.PreviewCloudfilename != nil { + return *m.PreviewCloudfilename + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetTitle() string { + if m != nil && m.Title != nil { + return *m.Title + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetFileDescription() string { + if m != nil && m.FileDescription != nil { + return *m.FileDescription + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetFileType() uint32 { + if m != nil && m.FileType != nil { + return *m.FileType + } + return 0 +} + +func (m *CPublishedFile_Publish_Request) GetConsumerShortcutName() string { + if m != nil && m.ConsumerShortcutName != nil { + return *m.ConsumerShortcutName + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetYoutubeUsername() string { + if m != nil && m.YoutubeUsername != nil { + return *m.YoutubeUsername + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetYoutubeVideoid() string { + if m != nil && m.YoutubeVideoid != nil { + return *m.YoutubeVideoid + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetVisibility() uint32 { + if m != nil && m.Visibility != nil { + return *m.Visibility + } + return 0 +} + +func (m *CPublishedFile_Publish_Request) GetRedirectUri() string { + if m != nil && m.RedirectUri != nil { + return *m.RedirectUri + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *CPublishedFile_Publish_Request) GetCollectionType() string { + if m != nil && m.CollectionType != nil { + return *m.CollectionType + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetGameType() string { + if m != nil && m.GameType != nil { + return *m.GameType + } + return "" +} + +func (m *CPublishedFile_Publish_Request) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +type CPublishedFile_Publish_Response struct { + Publishedfileid *uint64 `protobuf:"varint,1,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + RedirectUri *string `protobuf:"bytes,2,opt,name=redirect_uri" json:"redirect_uri,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Publish_Response) Reset() { *m = CPublishedFile_Publish_Response{} } +func (m *CPublishedFile_Publish_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Publish_Response) ProtoMessage() {} +func (*CPublishedFile_Publish_Response) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{7} } + +func (m *CPublishedFile_Publish_Response) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *CPublishedFile_Publish_Response) GetRedirectUri() string { + if m != nil && m.RedirectUri != nil { + return *m.RedirectUri + } + return "" +} + +type CPublishedFile_GetDetails_Request struct { + Publishedfileids []uint64 `protobuf:"fixed64,1,rep,name=publishedfileids" json:"publishedfileids,omitempty"` + Includetags *bool `protobuf:"varint,2,opt,name=includetags" json:"includetags,omitempty"` + Includeadditionalpreviews *bool `protobuf:"varint,3,opt,name=includeadditionalpreviews" json:"includeadditionalpreviews,omitempty"` + Includechildren *bool `protobuf:"varint,4,opt,name=includechildren" json:"includechildren,omitempty"` + Includekvtags *bool `protobuf:"varint,5,opt,name=includekvtags" json:"includekvtags,omitempty"` + Includevotes *bool `protobuf:"varint,6,opt,name=includevotes" json:"includevotes,omitempty"` + ShortDescription *bool `protobuf:"varint,8,opt,name=short_description" json:"short_description,omitempty"` + Includeforsaledata *bool `protobuf:"varint,10,opt,name=includeforsaledata" json:"includeforsaledata,omitempty"` + Includemetadata *bool `protobuf:"varint,11,opt,name=includemetadata" json:"includemetadata,omitempty"` + Language *int32 `protobuf:"varint,12,opt,name=language,def=0" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetDetails_Request) Reset() { *m = CPublishedFile_GetDetails_Request{} } +func (m *CPublishedFile_GetDetails_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetDetails_Request) ProtoMessage() {} +func (*CPublishedFile_GetDetails_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{8} +} + +const Default_CPublishedFile_GetDetails_Request_Language int32 = 0 + +func (m *CPublishedFile_GetDetails_Request) GetPublishedfileids() []uint64 { + if m != nil { + return m.Publishedfileids + } + return nil +} + +func (m *CPublishedFile_GetDetails_Request) GetIncludetags() bool { + if m != nil && m.Includetags != nil { + return *m.Includetags + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetIncludeadditionalpreviews() bool { + if m != nil && m.Includeadditionalpreviews != nil { + return *m.Includeadditionalpreviews + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetIncludechildren() bool { + if m != nil && m.Includechildren != nil { + return *m.Includechildren + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetIncludekvtags() bool { + if m != nil && m.Includekvtags != nil { + return *m.Includekvtags + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetIncludevotes() bool { + if m != nil && m.Includevotes != nil { + return *m.Includevotes + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetShortDescription() bool { + if m != nil && m.ShortDescription != nil { + return *m.ShortDescription + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetIncludeforsaledata() bool { + if m != nil && m.Includeforsaledata != nil { + return *m.Includeforsaledata + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetIncludemetadata() bool { + if m != nil && m.Includemetadata != nil { + return *m.Includemetadata + } + return false +} + +func (m *CPublishedFile_GetDetails_Request) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return Default_CPublishedFile_GetDetails_Request_Language +} + +type PublishedFileDetails struct { + Result *uint32 `protobuf:"varint,1,opt,name=result" json:"result,omitempty"` + Publishedfileid *uint64 `protobuf:"varint,2,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + Creator *uint64 `protobuf:"fixed64,3,opt,name=creator" json:"creator,omitempty"` + CreatorAppid *uint32 `protobuf:"varint,4,opt,name=creator_appid" json:"creator_appid,omitempty"` + ConsumerAppid *uint32 `protobuf:"varint,5,opt,name=consumer_appid" json:"consumer_appid,omitempty"` + ConsumerShortcutid *uint32 `protobuf:"varint,6,opt,name=consumer_shortcutid" json:"consumer_shortcutid,omitempty"` + Filename *string `protobuf:"bytes,7,opt,name=filename" json:"filename,omitempty"` + FileSize *uint64 `protobuf:"varint,8,opt,name=file_size" json:"file_size,omitempty"` + PreviewFileSize *uint64 `protobuf:"varint,9,opt,name=preview_file_size" json:"preview_file_size,omitempty"` + FileUrl *string `protobuf:"bytes,10,opt,name=file_url" json:"file_url,omitempty"` + PreviewUrl *string `protobuf:"bytes,11,opt,name=preview_url" json:"preview_url,omitempty"` + Youtubevideoid *string `protobuf:"bytes,12,opt,name=youtubevideoid" json:"youtubevideoid,omitempty"` + Url *string `protobuf:"bytes,13,opt,name=url" json:"url,omitempty"` + HcontentFile *uint64 `protobuf:"fixed64,14,opt,name=hcontent_file" json:"hcontent_file,omitempty"` + HcontentPreview *uint64 `protobuf:"fixed64,15,opt,name=hcontent_preview" json:"hcontent_preview,omitempty"` + Title *string `protobuf:"bytes,16,opt,name=title" json:"title,omitempty"` + FileDescription *string `protobuf:"bytes,17,opt,name=file_description" json:"file_description,omitempty"` + ShortDescription *string `protobuf:"bytes,18,opt,name=short_description" json:"short_description,omitempty"` + TimeCreated *uint32 `protobuf:"varint,19,opt,name=time_created" json:"time_created,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,20,opt,name=time_updated" json:"time_updated,omitempty"` + Visibility *uint32 `protobuf:"varint,21,opt,name=visibility" json:"visibility,omitempty"` + Flags *uint32 `protobuf:"varint,22,opt,name=flags" json:"flags,omitempty"` + WorkshopFile *bool `protobuf:"varint,23,opt,name=workshop_file" json:"workshop_file,omitempty"` + WorkshopAccepted *bool `protobuf:"varint,24,opt,name=workshop_accepted" json:"workshop_accepted,omitempty"` + ShowSubscribeAll *bool `protobuf:"varint,25,opt,name=show_subscribe_all" json:"show_subscribe_all,omitempty"` + NumCommentsDeveloper *int32 `protobuf:"varint,26,opt,name=num_comments_developer" json:"num_comments_developer,omitempty"` + NumCommentsPublic *int32 `protobuf:"varint,27,opt,name=num_comments_public" json:"num_comments_public,omitempty"` + Banned *bool `protobuf:"varint,28,opt,name=banned" json:"banned,omitempty"` + BanReason *string `protobuf:"bytes,29,opt,name=ban_reason" json:"ban_reason,omitempty"` + Banner *uint64 `protobuf:"fixed64,30,opt,name=banner" json:"banner,omitempty"` + CanBeDeleted *bool `protobuf:"varint,31,opt,name=can_be_deleted" json:"can_be_deleted,omitempty"` + Incompatible *bool `protobuf:"varint,32,opt,name=incompatible" json:"incompatible,omitempty"` + AppName *string `protobuf:"bytes,33,opt,name=app_name" json:"app_name,omitempty"` + FileType *uint32 `protobuf:"varint,34,opt,name=file_type" json:"file_type,omitempty"` + CanSubscribe *bool `protobuf:"varint,35,opt,name=can_subscribe" json:"can_subscribe,omitempty"` + Subscriptions *uint32 `protobuf:"varint,36,opt,name=subscriptions" json:"subscriptions,omitempty"` + Favorited *uint32 `protobuf:"varint,37,opt,name=favorited" json:"favorited,omitempty"` + Followers *uint32 `protobuf:"varint,38,opt,name=followers" json:"followers,omitempty"` + LifetimeSubscriptions *uint32 `protobuf:"varint,39,opt,name=lifetime_subscriptions" json:"lifetime_subscriptions,omitempty"` + LifetimeFavorited *uint32 `protobuf:"varint,40,opt,name=lifetime_favorited" json:"lifetime_favorited,omitempty"` + LifetimeFollowers *uint32 `protobuf:"varint,41,opt,name=lifetime_followers" json:"lifetime_followers,omitempty"` + Views *uint32 `protobuf:"varint,42,opt,name=views" json:"views,omitempty"` + ImageWidth *uint32 `protobuf:"varint,43,opt,name=image_width" json:"image_width,omitempty"` + ImageHeight *uint32 `protobuf:"varint,44,opt,name=image_height" json:"image_height,omitempty"` + ImageUrl *string `protobuf:"bytes,45,opt,name=image_url" json:"image_url,omitempty"` + SpoilerTag *bool `protobuf:"varint,46,opt,name=spoiler_tag" json:"spoiler_tag,omitempty"` + Shortcutid *uint32 `protobuf:"varint,47,opt,name=shortcutid" json:"shortcutid,omitempty"` + Shortcutname *string `protobuf:"bytes,48,opt,name=shortcutname" json:"shortcutname,omitempty"` + NumChildren *uint32 `protobuf:"varint,49,opt,name=num_children" json:"num_children,omitempty"` + NumReports *uint32 `protobuf:"varint,50,opt,name=num_reports" json:"num_reports,omitempty"` + Previews []*PublishedFileDetails_Preview `protobuf:"bytes,51,rep,name=previews" json:"previews,omitempty"` + Tags []*PublishedFileDetails_Tag `protobuf:"bytes,52,rep,name=tags" json:"tags,omitempty"` + Children []*PublishedFileDetails_Child `protobuf:"bytes,53,rep,name=children" json:"children,omitempty"` + Kvtags []*PublishedFileDetails_KVTag `protobuf:"bytes,54,rep,name=kvtags" json:"kvtags,omitempty"` + VoteData *PublishedFileDetails_VoteData `protobuf:"bytes,55,opt,name=vote_data" json:"vote_data,omitempty"` + TimeSubscribed *uint32 `protobuf:"varint,56,opt,name=time_subscribed" json:"time_subscribed,omitempty"` + ForSaleData *PublishedFileDetails_ForSaleData `protobuf:"bytes,57,opt,name=for_sale_data" json:"for_sale_data,omitempty"` + Metadata *string `protobuf:"bytes,58,opt,name=metadata" json:"metadata,omitempty"` + IncompatibleActor *uint64 `protobuf:"fixed64,59,opt,name=incompatible_actor" json:"incompatible_actor,omitempty"` + IncompatibleTimestamp *uint32 `protobuf:"varint,60,opt,name=incompatible_timestamp" json:"incompatible_timestamp,omitempty"` + Language *int32 `protobuf:"varint,61,opt,name=language,def=0" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublishedFileDetails) Reset() { *m = PublishedFileDetails{} } +func (m *PublishedFileDetails) String() string { return proto.CompactTextString(m) } +func (*PublishedFileDetails) ProtoMessage() {} +func (*PublishedFileDetails) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{9} } + +const Default_PublishedFileDetails_Language int32 = 0 + +func (m *PublishedFileDetails) GetResult() uint32 { + if m != nil && m.Result != nil { + return *m.Result + } + return 0 +} + +func (m *PublishedFileDetails) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *PublishedFileDetails) GetCreator() uint64 { + if m != nil && m.Creator != nil { + return *m.Creator + } + return 0 +} + +func (m *PublishedFileDetails) GetCreatorAppid() uint32 { + if m != nil && m.CreatorAppid != nil { + return *m.CreatorAppid + } + return 0 +} + +func (m *PublishedFileDetails) GetConsumerAppid() uint32 { + if m != nil && m.ConsumerAppid != nil { + return *m.ConsumerAppid + } + return 0 +} + +func (m *PublishedFileDetails) GetConsumerShortcutid() uint32 { + if m != nil && m.ConsumerShortcutid != nil { + return *m.ConsumerShortcutid + } + return 0 +} + +func (m *PublishedFileDetails) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *PublishedFileDetails) GetFileSize() uint64 { + if m != nil && m.FileSize != nil { + return *m.FileSize + } + return 0 +} + +func (m *PublishedFileDetails) GetPreviewFileSize() uint64 { + if m != nil && m.PreviewFileSize != nil { + return *m.PreviewFileSize + } + return 0 +} + +func (m *PublishedFileDetails) GetFileUrl() string { + if m != nil && m.FileUrl != nil { + return *m.FileUrl + } + return "" +} + +func (m *PublishedFileDetails) GetPreviewUrl() string { + if m != nil && m.PreviewUrl != nil { + return *m.PreviewUrl + } + return "" +} + +func (m *PublishedFileDetails) GetYoutubevideoid() string { + if m != nil && m.Youtubevideoid != nil { + return *m.Youtubevideoid + } + return "" +} + +func (m *PublishedFileDetails) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *PublishedFileDetails) GetHcontentFile() uint64 { + if m != nil && m.HcontentFile != nil { + return *m.HcontentFile + } + return 0 +} + +func (m *PublishedFileDetails) GetHcontentPreview() uint64 { + if m != nil && m.HcontentPreview != nil { + return *m.HcontentPreview + } + return 0 +} + +func (m *PublishedFileDetails) GetTitle() string { + if m != nil && m.Title != nil { + return *m.Title + } + return "" +} + +func (m *PublishedFileDetails) GetFileDescription() string { + if m != nil && m.FileDescription != nil { + return *m.FileDescription + } + return "" +} + +func (m *PublishedFileDetails) GetShortDescription() string { + if m != nil && m.ShortDescription != nil { + return *m.ShortDescription + } + return "" +} + +func (m *PublishedFileDetails) GetTimeCreated() uint32 { + if m != nil && m.TimeCreated != nil { + return *m.TimeCreated + } + return 0 +} + +func (m *PublishedFileDetails) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +func (m *PublishedFileDetails) GetVisibility() uint32 { + if m != nil && m.Visibility != nil { + return *m.Visibility + } + return 0 +} + +func (m *PublishedFileDetails) GetFlags() uint32 { + if m != nil && m.Flags != nil { + return *m.Flags + } + return 0 +} + +func (m *PublishedFileDetails) GetWorkshopFile() bool { + if m != nil && m.WorkshopFile != nil { + return *m.WorkshopFile + } + return false +} + +func (m *PublishedFileDetails) GetWorkshopAccepted() bool { + if m != nil && m.WorkshopAccepted != nil { + return *m.WorkshopAccepted + } + return false +} + +func (m *PublishedFileDetails) GetShowSubscribeAll() bool { + if m != nil && m.ShowSubscribeAll != nil { + return *m.ShowSubscribeAll + } + return false +} + +func (m *PublishedFileDetails) GetNumCommentsDeveloper() int32 { + if m != nil && m.NumCommentsDeveloper != nil { + return *m.NumCommentsDeveloper + } + return 0 +} + +func (m *PublishedFileDetails) GetNumCommentsPublic() int32 { + if m != nil && m.NumCommentsPublic != nil { + return *m.NumCommentsPublic + } + return 0 +} + +func (m *PublishedFileDetails) GetBanned() bool { + if m != nil && m.Banned != nil { + return *m.Banned + } + return false +} + +func (m *PublishedFileDetails) GetBanReason() string { + if m != nil && m.BanReason != nil { + return *m.BanReason + } + return "" +} + +func (m *PublishedFileDetails) GetBanner() uint64 { + if m != nil && m.Banner != nil { + return *m.Banner + } + return 0 +} + +func (m *PublishedFileDetails) GetCanBeDeleted() bool { + if m != nil && m.CanBeDeleted != nil { + return *m.CanBeDeleted + } + return false +} + +func (m *PublishedFileDetails) GetIncompatible() bool { + if m != nil && m.Incompatible != nil { + return *m.Incompatible + } + return false +} + +func (m *PublishedFileDetails) GetAppName() string { + if m != nil && m.AppName != nil { + return *m.AppName + } + return "" +} + +func (m *PublishedFileDetails) GetFileType() uint32 { + if m != nil && m.FileType != nil { + return *m.FileType + } + return 0 +} + +func (m *PublishedFileDetails) GetCanSubscribe() bool { + if m != nil && m.CanSubscribe != nil { + return *m.CanSubscribe + } + return false +} + +func (m *PublishedFileDetails) GetSubscriptions() uint32 { + if m != nil && m.Subscriptions != nil { + return *m.Subscriptions + } + return 0 +} + +func (m *PublishedFileDetails) GetFavorited() uint32 { + if m != nil && m.Favorited != nil { + return *m.Favorited + } + return 0 +} + +func (m *PublishedFileDetails) GetFollowers() uint32 { + if m != nil && m.Followers != nil { + return *m.Followers + } + return 0 +} + +func (m *PublishedFileDetails) GetLifetimeSubscriptions() uint32 { + if m != nil && m.LifetimeSubscriptions != nil { + return *m.LifetimeSubscriptions + } + return 0 +} + +func (m *PublishedFileDetails) GetLifetimeFavorited() uint32 { + if m != nil && m.LifetimeFavorited != nil { + return *m.LifetimeFavorited + } + return 0 +} + +func (m *PublishedFileDetails) GetLifetimeFollowers() uint32 { + if m != nil && m.LifetimeFollowers != nil { + return *m.LifetimeFollowers + } + return 0 +} + +func (m *PublishedFileDetails) GetViews() uint32 { + if m != nil && m.Views != nil { + return *m.Views + } + return 0 +} + +func (m *PublishedFileDetails) GetImageWidth() uint32 { + if m != nil && m.ImageWidth != nil { + return *m.ImageWidth + } + return 0 +} + +func (m *PublishedFileDetails) GetImageHeight() uint32 { + if m != nil && m.ImageHeight != nil { + return *m.ImageHeight + } + return 0 +} + +func (m *PublishedFileDetails) GetImageUrl() string { + if m != nil && m.ImageUrl != nil { + return *m.ImageUrl + } + return "" +} + +func (m *PublishedFileDetails) GetSpoilerTag() bool { + if m != nil && m.SpoilerTag != nil { + return *m.SpoilerTag + } + return false +} + +func (m *PublishedFileDetails) GetShortcutid() uint32 { + if m != nil && m.Shortcutid != nil { + return *m.Shortcutid + } + return 0 +} + +func (m *PublishedFileDetails) GetShortcutname() string { + if m != nil && m.Shortcutname != nil { + return *m.Shortcutname + } + return "" +} + +func (m *PublishedFileDetails) GetNumChildren() uint32 { + if m != nil && m.NumChildren != nil { + return *m.NumChildren + } + return 0 +} + +func (m *PublishedFileDetails) GetNumReports() uint32 { + if m != nil && m.NumReports != nil { + return *m.NumReports + } + return 0 +} + +func (m *PublishedFileDetails) GetPreviews() []*PublishedFileDetails_Preview { + if m != nil { + return m.Previews + } + return nil +} + +func (m *PublishedFileDetails) GetTags() []*PublishedFileDetails_Tag { + if m != nil { + return m.Tags + } + return nil +} + +func (m *PublishedFileDetails) GetChildren() []*PublishedFileDetails_Child { + if m != nil { + return m.Children + } + return nil +} + +func (m *PublishedFileDetails) GetKvtags() []*PublishedFileDetails_KVTag { + if m != nil { + return m.Kvtags + } + return nil +} + +func (m *PublishedFileDetails) GetVoteData() *PublishedFileDetails_VoteData { + if m != nil { + return m.VoteData + } + return nil +} + +func (m *PublishedFileDetails) GetTimeSubscribed() uint32 { + if m != nil && m.TimeSubscribed != nil { + return *m.TimeSubscribed + } + return 0 +} + +func (m *PublishedFileDetails) GetForSaleData() *PublishedFileDetails_ForSaleData { + if m != nil { + return m.ForSaleData + } + return nil +} + +func (m *PublishedFileDetails) GetMetadata() string { + if m != nil && m.Metadata != nil { + return *m.Metadata + } + return "" +} + +func (m *PublishedFileDetails) GetIncompatibleActor() uint64 { + if m != nil && m.IncompatibleActor != nil { + return *m.IncompatibleActor + } + return 0 +} + +func (m *PublishedFileDetails) GetIncompatibleTimestamp() uint32 { + if m != nil && m.IncompatibleTimestamp != nil { + return *m.IncompatibleTimestamp + } + return 0 +} + +func (m *PublishedFileDetails) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return Default_PublishedFileDetails_Language +} + +type PublishedFileDetails_Tag struct { + Tag *string `protobuf:"bytes,1,opt,name=tag" json:"tag,omitempty"` + Adminonly *bool `protobuf:"varint,2,opt,name=adminonly" json:"adminonly,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublishedFileDetails_Tag) Reset() { *m = PublishedFileDetails_Tag{} } +func (m *PublishedFileDetails_Tag) String() string { return proto.CompactTextString(m) } +func (*PublishedFileDetails_Tag) ProtoMessage() {} +func (*PublishedFileDetails_Tag) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{9, 0} } + +func (m *PublishedFileDetails_Tag) GetTag() string { + if m != nil && m.Tag != nil { + return *m.Tag + } + return "" +} + +func (m *PublishedFileDetails_Tag) GetAdminonly() bool { + if m != nil && m.Adminonly != nil { + return *m.Adminonly + } + return false +} + +type PublishedFileDetails_Preview struct { + Previewid *uint64 `protobuf:"varint,1,opt,name=previewid" json:"previewid,omitempty"` + Sortorder *uint32 `protobuf:"varint,2,opt,name=sortorder" json:"sortorder,omitempty"` + Url *string `protobuf:"bytes,3,opt,name=url" json:"url,omitempty"` + Size *uint32 `protobuf:"varint,4,opt,name=size" json:"size,omitempty"` + Filename *string `protobuf:"bytes,5,opt,name=filename" json:"filename,omitempty"` + Youtubevideoid *string `protobuf:"bytes,6,opt,name=youtubevideoid" json:"youtubevideoid,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublishedFileDetails_Preview) Reset() { *m = PublishedFileDetails_Preview{} } +func (m *PublishedFileDetails_Preview) String() string { return proto.CompactTextString(m) } +func (*PublishedFileDetails_Preview) ProtoMessage() {} +func (*PublishedFileDetails_Preview) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{9, 1} } + +func (m *PublishedFileDetails_Preview) GetPreviewid() uint64 { + if m != nil && m.Previewid != nil { + return *m.Previewid + } + return 0 +} + +func (m *PublishedFileDetails_Preview) GetSortorder() uint32 { + if m != nil && m.Sortorder != nil { + return *m.Sortorder + } + return 0 +} + +func (m *PublishedFileDetails_Preview) GetUrl() string { + if m != nil && m.Url != nil { + return *m.Url + } + return "" +} + +func (m *PublishedFileDetails_Preview) GetSize() uint32 { + if m != nil && m.Size != nil { + return *m.Size + } + return 0 +} + +func (m *PublishedFileDetails_Preview) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *PublishedFileDetails_Preview) GetYoutubevideoid() string { + if m != nil && m.Youtubevideoid != nil { + return *m.Youtubevideoid + } + return "" +} + +type PublishedFileDetails_Child struct { + Publishedfileid *uint64 `protobuf:"varint,1,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + Sortorder *uint32 `protobuf:"varint,2,opt,name=sortorder" json:"sortorder,omitempty"` + FileType *uint32 `protobuf:"varint,3,opt,name=file_type" json:"file_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublishedFileDetails_Child) Reset() { *m = PublishedFileDetails_Child{} } +func (m *PublishedFileDetails_Child) String() string { return proto.CompactTextString(m) } +func (*PublishedFileDetails_Child) ProtoMessage() {} +func (*PublishedFileDetails_Child) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{9, 2} } + +func (m *PublishedFileDetails_Child) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *PublishedFileDetails_Child) GetSortorder() uint32 { + if m != nil && m.Sortorder != nil { + return *m.Sortorder + } + return 0 +} + +func (m *PublishedFileDetails_Child) GetFileType() uint32 { + if m != nil && m.FileType != nil { + return *m.FileType + } + return 0 +} + +type PublishedFileDetails_KVTag struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublishedFileDetails_KVTag) Reset() { *m = PublishedFileDetails_KVTag{} } +func (m *PublishedFileDetails_KVTag) String() string { return proto.CompactTextString(m) } +func (*PublishedFileDetails_KVTag) ProtoMessage() {} +func (*PublishedFileDetails_KVTag) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{9, 3} } + +func (m *PublishedFileDetails_KVTag) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *PublishedFileDetails_KVTag) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type PublishedFileDetails_VoteData struct { + Score *float32 `protobuf:"fixed32,1,opt,name=score" json:"score,omitempty"` + VotesUp *uint32 `protobuf:"varint,2,opt,name=votes_up" json:"votes_up,omitempty"` + VotesDown *uint32 `protobuf:"varint,3,opt,name=votes_down" json:"votes_down,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublishedFileDetails_VoteData) Reset() { *m = PublishedFileDetails_VoteData{} } +func (m *PublishedFileDetails_VoteData) String() string { return proto.CompactTextString(m) } +func (*PublishedFileDetails_VoteData) ProtoMessage() {} +func (*PublishedFileDetails_VoteData) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{9, 4} +} + +func (m *PublishedFileDetails_VoteData) GetScore() float32 { + if m != nil && m.Score != nil { + return *m.Score + } + return 0 +} + +func (m *PublishedFileDetails_VoteData) GetVotesUp() uint32 { + if m != nil && m.VotesUp != nil { + return *m.VotesUp + } + return 0 +} + +func (m *PublishedFileDetails_VoteData) GetVotesDown() uint32 { + if m != nil && m.VotesDown != nil { + return *m.VotesDown + } + return 0 +} + +type PublishedFileDetails_ForSaleData struct { + IsForSale *bool `protobuf:"varint,1,opt,name=is_for_sale" json:"is_for_sale,omitempty"` + PriceCategory *uint32 `protobuf:"varint,2,opt,name=price_category" json:"price_category,omitempty"` + Estatus *PublishedFileDetails_EPublishedFileForSaleStatus `protobuf:"varint,3,opt,name=estatus,enum=PublishedFileDetails_EPublishedFileForSaleStatus,def=0" json:"estatus,omitempty"` + PriceCategoryFloor *uint32 `protobuf:"varint,4,opt,name=price_category_floor" json:"price_category_floor,omitempty"` + PriceIsPayWhatYouWant *bool `protobuf:"varint,5,opt,name=price_is_pay_what_you_want" json:"price_is_pay_what_you_want,omitempty"` + DiscountPercentage *uint32 `protobuf:"varint,6,opt,name=discount_percentage" json:"discount_percentage,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PublishedFileDetails_ForSaleData) Reset() { *m = PublishedFileDetails_ForSaleData{} } +func (m *PublishedFileDetails_ForSaleData) String() string { return proto.CompactTextString(m) } +func (*PublishedFileDetails_ForSaleData) ProtoMessage() {} +func (*PublishedFileDetails_ForSaleData) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{9, 5} +} + +const Default_PublishedFileDetails_ForSaleData_Estatus PublishedFileDetails_EPublishedFileForSaleStatus = PublishedFileDetails_k_PFFSS_NotForSale + +func (m *PublishedFileDetails_ForSaleData) GetIsForSale() bool { + if m != nil && m.IsForSale != nil { + return *m.IsForSale + } + return false +} + +func (m *PublishedFileDetails_ForSaleData) GetPriceCategory() uint32 { + if m != nil && m.PriceCategory != nil { + return *m.PriceCategory + } + return 0 +} + +func (m *PublishedFileDetails_ForSaleData) GetEstatus() PublishedFileDetails_EPublishedFileForSaleStatus { + if m != nil && m.Estatus != nil { + return *m.Estatus + } + return Default_PublishedFileDetails_ForSaleData_Estatus +} + +func (m *PublishedFileDetails_ForSaleData) GetPriceCategoryFloor() uint32 { + if m != nil && m.PriceCategoryFloor != nil { + return *m.PriceCategoryFloor + } + return 0 +} + +func (m *PublishedFileDetails_ForSaleData) GetPriceIsPayWhatYouWant() bool { + if m != nil && m.PriceIsPayWhatYouWant != nil { + return *m.PriceIsPayWhatYouWant + } + return false +} + +func (m *PublishedFileDetails_ForSaleData) GetDiscountPercentage() uint32 { + if m != nil && m.DiscountPercentage != nil { + return *m.DiscountPercentage + } + return 0 +} + +type CPublishedFile_GetDetails_Response struct { + Publishedfiledetails []*PublishedFileDetails `protobuf:"bytes,1,rep,name=publishedfiledetails" json:"publishedfiledetails,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetDetails_Response) Reset() { *m = CPublishedFile_GetDetails_Response{} } +func (m *CPublishedFile_GetDetails_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetDetails_Response) ProtoMessage() {} +func (*CPublishedFile_GetDetails_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{10} +} + +func (m *CPublishedFile_GetDetails_Response) GetPublishedfiledetails() []*PublishedFileDetails { + if m != nil { + return m.Publishedfiledetails + } + return nil +} + +type CPublishedFile_GetItemInfo_Request struct { + AppId *uint32 `protobuf:"varint,1,opt,name=app_id" json:"app_id,omitempty"` + LastTimeUpdated *uint32 `protobuf:"varint,2,opt,name=last_time_updated" json:"last_time_updated,omitempty"` + WorkshopItems []*CPublishedFile_GetItemInfo_Request_WorkshopItem `protobuf:"bytes,3,rep,name=workshop_items" json:"workshop_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetItemInfo_Request) Reset() { *m = CPublishedFile_GetItemInfo_Request{} } +func (m *CPublishedFile_GetItemInfo_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetItemInfo_Request) ProtoMessage() {} +func (*CPublishedFile_GetItemInfo_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{11} +} + +func (m *CPublishedFile_GetItemInfo_Request) GetAppId() uint32 { + if m != nil && m.AppId != nil { + return *m.AppId + } + return 0 +} + +func (m *CPublishedFile_GetItemInfo_Request) GetLastTimeUpdated() uint32 { + if m != nil && m.LastTimeUpdated != nil { + return *m.LastTimeUpdated + } + return 0 +} + +func (m *CPublishedFile_GetItemInfo_Request) GetWorkshopItems() []*CPublishedFile_GetItemInfo_Request_WorkshopItem { + if m != nil { + return m.WorkshopItems + } + return nil +} + +type CPublishedFile_GetItemInfo_Request_WorkshopItem struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,2,opt,name=time_updated" json:"time_updated,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetItemInfo_Request_WorkshopItem) Reset() { + *m = CPublishedFile_GetItemInfo_Request_WorkshopItem{} +} +func (m *CPublishedFile_GetItemInfo_Request_WorkshopItem) String() string { + return proto.CompactTextString(m) +} +func (*CPublishedFile_GetItemInfo_Request_WorkshopItem) ProtoMessage() {} +func (*CPublishedFile_GetItemInfo_Request_WorkshopItem) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{11, 0} +} + +func (m *CPublishedFile_GetItemInfo_Request_WorkshopItem) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CPublishedFile_GetItemInfo_Request_WorkshopItem) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +type CPublishedFile_GetItemInfo_Response struct { + UpdateTime *uint32 `protobuf:"varint,1,opt,name=update_time" json:"update_time,omitempty"` + WorkshopItems []*CPublishedFile_GetItemInfo_Response_WorkshopItemInfo `protobuf:"bytes,2,rep,name=workshop_items" json:"workshop_items,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetItemInfo_Response) Reset() { *m = CPublishedFile_GetItemInfo_Response{} } +func (m *CPublishedFile_GetItemInfo_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetItemInfo_Response) ProtoMessage() {} +func (*CPublishedFile_GetItemInfo_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{12} +} + +func (m *CPublishedFile_GetItemInfo_Response) GetUpdateTime() uint32 { + if m != nil && m.UpdateTime != nil { + return *m.UpdateTime + } + return 0 +} + +func (m *CPublishedFile_GetItemInfo_Response) GetWorkshopItems() []*CPublishedFile_GetItemInfo_Response_WorkshopItemInfo { + if m != nil { + return m.WorkshopItems + } + return nil +} + +type CPublishedFile_GetItemInfo_Response_WorkshopItemInfo struct { + PublishedFileId *uint64 `protobuf:"fixed64,1,opt,name=published_file_id" json:"published_file_id,omitempty"` + TimeUpdated *uint32 `protobuf:"varint,2,opt,name=time_updated" json:"time_updated,omitempty"` + ManifestId *uint64 `protobuf:"fixed64,3,opt,name=manifest_id" json:"manifest_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetItemInfo_Response_WorkshopItemInfo) Reset() { + *m = CPublishedFile_GetItemInfo_Response_WorkshopItemInfo{} +} +func (m *CPublishedFile_GetItemInfo_Response_WorkshopItemInfo) String() string { + return proto.CompactTextString(m) +} +func (*CPublishedFile_GetItemInfo_Response_WorkshopItemInfo) ProtoMessage() {} +func (*CPublishedFile_GetItemInfo_Response_WorkshopItemInfo) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{12, 0} +} + +func (m *CPublishedFile_GetItemInfo_Response_WorkshopItemInfo) GetPublishedFileId() uint64 { + if m != nil && m.PublishedFileId != nil { + return *m.PublishedFileId + } + return 0 +} + +func (m *CPublishedFile_GetItemInfo_Response_WorkshopItemInfo) GetTimeUpdated() uint32 { + if m != nil && m.TimeUpdated != nil { + return *m.TimeUpdated + } + return 0 +} + +func (m *CPublishedFile_GetItemInfo_Response_WorkshopItemInfo) GetManifestId() uint64 { + if m != nil && m.ManifestId != nil { + return *m.ManifestId + } + return 0 +} + +type CPublishedFile_GetUserFiles_Request struct { + Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"` + Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"` + Page *uint32 `protobuf:"varint,4,opt,name=page,def=1" json:"page,omitempty"` + Numperpage *uint32 `protobuf:"varint,5,opt,name=numperpage,def=1" json:"numperpage,omitempty"` + Type *string `protobuf:"bytes,6,opt,name=type,def=myfiles" json:"type,omitempty"` + Sortmethod *string `protobuf:"bytes,7,opt,name=sortmethod,def=lastupdated" json:"sortmethod,omitempty"` + Privacy *uint32 `protobuf:"varint,9,opt,name=privacy" json:"privacy,omitempty"` + Requiredtags []string `protobuf:"bytes,10,rep,name=requiredtags" json:"requiredtags,omitempty"` + Excludedtags []string `protobuf:"bytes,11,rep,name=excludedtags" json:"excludedtags,omitempty"` + RequiredKvTags []*CPublishedFile_GetUserFiles_Request_KVTag `protobuf:"bytes,30,rep,name=required_kv_tags" json:"required_kv_tags,omitempty"` + Filetype *uint32 `protobuf:"varint,14,opt,name=filetype" json:"filetype,omitempty"` + CreatorAppid *uint32 `protobuf:"varint,15,opt,name=creator_appid" json:"creator_appid,omitempty"` + MatchCloudFilename *string `protobuf:"bytes,16,opt,name=match_cloud_filename" json:"match_cloud_filename,omitempty"` + CacheMaxAgeSeconds *uint32 `protobuf:"varint,27,opt,name=cache_max_age_seconds,def=0" json:"cache_max_age_seconds,omitempty"` + Language *int32 `protobuf:"varint,29,opt,name=language,def=0" json:"language,omitempty"` + Totalonly *bool `protobuf:"varint,17,opt,name=totalonly" json:"totalonly,omitempty"` + IdsOnly *bool `protobuf:"varint,18,opt,name=ids_only" json:"ids_only,omitempty"` + ReturnVoteData *bool `protobuf:"varint,19,opt,name=return_vote_data,def=1" json:"return_vote_data,omitempty"` + ReturnTags *bool `protobuf:"varint,20,opt,name=return_tags" json:"return_tags,omitempty"` + ReturnKvTags *bool `protobuf:"varint,21,opt,name=return_kv_tags,def=1" json:"return_kv_tags,omitempty"` + ReturnPreviews *bool `protobuf:"varint,22,opt,name=return_previews" json:"return_previews,omitempty"` + ReturnChildren *bool `protobuf:"varint,23,opt,name=return_children" json:"return_children,omitempty"` + ReturnShortDescription *bool `protobuf:"varint,24,opt,name=return_short_description,def=1" json:"return_short_description,omitempty"` + ReturnForSaleData *bool `protobuf:"varint,26,opt,name=return_for_sale_data" json:"return_for_sale_data,omitempty"` + ReturnMetadata *bool `protobuf:"varint,28,opt,name=return_metadata,def=0" json:"return_metadata,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetUserFiles_Request) Reset() { *m = CPublishedFile_GetUserFiles_Request{} } +func (m *CPublishedFile_GetUserFiles_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetUserFiles_Request) ProtoMessage() {} +func (*CPublishedFile_GetUserFiles_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{13} +} + +const Default_CPublishedFile_GetUserFiles_Request_Page uint32 = 1 +const Default_CPublishedFile_GetUserFiles_Request_Numperpage uint32 = 1 +const Default_CPublishedFile_GetUserFiles_Request_Type string = "myfiles" +const Default_CPublishedFile_GetUserFiles_Request_Sortmethod string = "lastupdated" +const Default_CPublishedFile_GetUserFiles_Request_CacheMaxAgeSeconds uint32 = 0 +const Default_CPublishedFile_GetUserFiles_Request_Language int32 = 0 +const Default_CPublishedFile_GetUserFiles_Request_ReturnVoteData bool = true +const Default_CPublishedFile_GetUserFiles_Request_ReturnKvTags bool = true +const Default_CPublishedFile_GetUserFiles_Request_ReturnShortDescription bool = true +const Default_CPublishedFile_GetUserFiles_Request_ReturnMetadata bool = false + +func (m *CPublishedFile_GetUserFiles_Request) GetSteamid() uint64 { + if m != nil && m.Steamid != nil { + return *m.Steamid + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Request) GetPage() uint32 { + if m != nil && m.Page != nil { + return *m.Page + } + return Default_CPublishedFile_GetUserFiles_Request_Page +} + +func (m *CPublishedFile_GetUserFiles_Request) GetNumperpage() uint32 { + if m != nil && m.Numperpage != nil { + return *m.Numperpage + } + return Default_CPublishedFile_GetUserFiles_Request_Numperpage +} + +func (m *CPublishedFile_GetUserFiles_Request) GetType() string { + if m != nil && m.Type != nil { + return *m.Type + } + return Default_CPublishedFile_GetUserFiles_Request_Type +} + +func (m *CPublishedFile_GetUserFiles_Request) GetSortmethod() string { + if m != nil && m.Sortmethod != nil { + return *m.Sortmethod + } + return Default_CPublishedFile_GetUserFiles_Request_Sortmethod +} + +func (m *CPublishedFile_GetUserFiles_Request) GetPrivacy() uint32 { + if m != nil && m.Privacy != nil { + return *m.Privacy + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Request) GetRequiredtags() []string { + if m != nil { + return m.Requiredtags + } + return nil +} + +func (m *CPublishedFile_GetUserFiles_Request) GetExcludedtags() []string { + if m != nil { + return m.Excludedtags + } + return nil +} + +func (m *CPublishedFile_GetUserFiles_Request) GetRequiredKvTags() []*CPublishedFile_GetUserFiles_Request_KVTag { + if m != nil { + return m.RequiredKvTags + } + return nil +} + +func (m *CPublishedFile_GetUserFiles_Request) GetFiletype() uint32 { + if m != nil && m.Filetype != nil { + return *m.Filetype + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Request) GetCreatorAppid() uint32 { + if m != nil && m.CreatorAppid != nil { + return *m.CreatorAppid + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Request) GetMatchCloudFilename() string { + if m != nil && m.MatchCloudFilename != nil { + return *m.MatchCloudFilename + } + return "" +} + +func (m *CPublishedFile_GetUserFiles_Request) GetCacheMaxAgeSeconds() uint32 { + if m != nil && m.CacheMaxAgeSeconds != nil { + return *m.CacheMaxAgeSeconds + } + return Default_CPublishedFile_GetUserFiles_Request_CacheMaxAgeSeconds +} + +func (m *CPublishedFile_GetUserFiles_Request) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return Default_CPublishedFile_GetUserFiles_Request_Language +} + +func (m *CPublishedFile_GetUserFiles_Request) GetTotalonly() bool { + if m != nil && m.Totalonly != nil { + return *m.Totalonly + } + return false +} + +func (m *CPublishedFile_GetUserFiles_Request) GetIdsOnly() bool { + if m != nil && m.IdsOnly != nil { + return *m.IdsOnly + } + return false +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnVoteData() bool { + if m != nil && m.ReturnVoteData != nil { + return *m.ReturnVoteData + } + return Default_CPublishedFile_GetUserFiles_Request_ReturnVoteData +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnTags() bool { + if m != nil && m.ReturnTags != nil { + return *m.ReturnTags + } + return false +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnKvTags() bool { + if m != nil && m.ReturnKvTags != nil { + return *m.ReturnKvTags + } + return Default_CPublishedFile_GetUserFiles_Request_ReturnKvTags +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnPreviews() bool { + if m != nil && m.ReturnPreviews != nil { + return *m.ReturnPreviews + } + return false +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnChildren() bool { + if m != nil && m.ReturnChildren != nil { + return *m.ReturnChildren + } + return false +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnShortDescription() bool { + if m != nil && m.ReturnShortDescription != nil { + return *m.ReturnShortDescription + } + return Default_CPublishedFile_GetUserFiles_Request_ReturnShortDescription +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnForSaleData() bool { + if m != nil && m.ReturnForSaleData != nil { + return *m.ReturnForSaleData + } + return false +} + +func (m *CPublishedFile_GetUserFiles_Request) GetReturnMetadata() bool { + if m != nil && m.ReturnMetadata != nil { + return *m.ReturnMetadata + } + return Default_CPublishedFile_GetUserFiles_Request_ReturnMetadata +} + +type CPublishedFile_GetUserFiles_Request_KVTag struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetUserFiles_Request_KVTag) Reset() { + *m = CPublishedFile_GetUserFiles_Request_KVTag{} +} +func (m *CPublishedFile_GetUserFiles_Request_KVTag) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetUserFiles_Request_KVTag) ProtoMessage() {} +func (*CPublishedFile_GetUserFiles_Request_KVTag) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{13, 0} +} + +func (m *CPublishedFile_GetUserFiles_Request_KVTag) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *CPublishedFile_GetUserFiles_Request_KVTag) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CPublishedFile_GetUserFiles_Response struct { + Total *uint32 `protobuf:"varint,1,opt,name=total" json:"total,omitempty"` + Startindex *uint32 `protobuf:"varint,2,opt,name=startindex" json:"startindex,omitempty"` + Publishedfiledetails []*PublishedFileDetails `protobuf:"bytes,3,rep,name=publishedfiledetails" json:"publishedfiledetails,omitempty"` + Apps []*CPublishedFile_GetUserFiles_Response_App `protobuf:"bytes,4,rep,name=apps" json:"apps,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetUserFiles_Response) Reset() { *m = CPublishedFile_GetUserFiles_Response{} } +func (m *CPublishedFile_GetUserFiles_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetUserFiles_Response) ProtoMessage() {} +func (*CPublishedFile_GetUserFiles_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{14} +} + +func (m *CPublishedFile_GetUserFiles_Response) GetTotal() uint32 { + if m != nil && m.Total != nil { + return *m.Total + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Response) GetStartindex() uint32 { + if m != nil && m.Startindex != nil { + return *m.Startindex + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Response) GetPublishedfiledetails() []*PublishedFileDetails { + if m != nil { + return m.Publishedfiledetails + } + return nil +} + +func (m *CPublishedFile_GetUserFiles_Response) GetApps() []*CPublishedFile_GetUserFiles_Response_App { + if m != nil { + return m.Apps + } + return nil +} + +type CPublishedFile_GetUserFiles_Response_App struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` + Shortcutid *uint32 `protobuf:"varint,3,opt,name=shortcutid" json:"shortcutid,omitempty"` + Private *bool `protobuf:"varint,4,opt,name=private" json:"private,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetUserFiles_Response_App) Reset() { + *m = CPublishedFile_GetUserFiles_Response_App{} +} +func (m *CPublishedFile_GetUserFiles_Response_App) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetUserFiles_Response_App) ProtoMessage() {} +func (*CPublishedFile_GetUserFiles_Response_App) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{14, 0} +} + +func (m *CPublishedFile_GetUserFiles_Response_App) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Response_App) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CPublishedFile_GetUserFiles_Response_App) GetShortcutid() uint32 { + if m != nil && m.Shortcutid != nil { + return *m.Shortcutid + } + return 0 +} + +func (m *CPublishedFile_GetUserFiles_Response_App) GetPrivate() bool { + if m != nil && m.Private != nil { + return *m.Private + } + return false +} + +type CPublishedFile_Update_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + Publishedfileid *uint64 `protobuf:"fixed64,2,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + Title *string `protobuf:"bytes,3,opt,name=title" json:"title,omitempty"` + FileDescription *string `protobuf:"bytes,4,opt,name=file_description" json:"file_description,omitempty"` + Visibility *uint32 `protobuf:"varint,5,opt,name=visibility" json:"visibility,omitempty"` + Tags []string `protobuf:"bytes,6,rep,name=tags" json:"tags,omitempty"` + Filename *string `protobuf:"bytes,7,opt,name=filename" json:"filename,omitempty"` + PreviewFilename *string `protobuf:"bytes,8,opt,name=preview_filename" json:"preview_filename,omitempty"` + ImageWidth *uint32 `protobuf:"varint,15,opt,name=image_width" json:"image_width,omitempty"` + ImageHeight *uint32 `protobuf:"varint,16,opt,name=image_height" json:"image_height,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Update_Request) Reset() { *m = CPublishedFile_Update_Request{} } +func (m *CPublishedFile_Update_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Update_Request) ProtoMessage() {} +func (*CPublishedFile_Update_Request) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{15} } + +func (m *CPublishedFile_Update_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_Update_Request) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *CPublishedFile_Update_Request) GetTitle() string { + if m != nil && m.Title != nil { + return *m.Title + } + return "" +} + +func (m *CPublishedFile_Update_Request) GetFileDescription() string { + if m != nil && m.FileDescription != nil { + return *m.FileDescription + } + return "" +} + +func (m *CPublishedFile_Update_Request) GetVisibility() uint32 { + if m != nil && m.Visibility != nil { + return *m.Visibility + } + return 0 +} + +func (m *CPublishedFile_Update_Request) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *CPublishedFile_Update_Request) GetFilename() string { + if m != nil && m.Filename != nil { + return *m.Filename + } + return "" +} + +func (m *CPublishedFile_Update_Request) GetPreviewFilename() string { + if m != nil && m.PreviewFilename != nil { + return *m.PreviewFilename + } + return "" +} + +func (m *CPublishedFile_Update_Request) GetImageWidth() uint32 { + if m != nil && m.ImageWidth != nil { + return *m.ImageWidth + } + return 0 +} + +func (m *CPublishedFile_Update_Request) GetImageHeight() uint32 { + if m != nil && m.ImageHeight != nil { + return *m.ImageHeight + } + return 0 +} + +type CPublishedFile_Update_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_Update_Response) Reset() { *m = CPublishedFile_Update_Response{} } +func (m *CPublishedFile_Update_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_Update_Response) ProtoMessage() {} +func (*CPublishedFile_Update_Response) Descriptor() ([]byte, []int) { return publishedfile_fileDescriptor0, []int{16} } + +type CPublishedFile_GetChangeHistoryEntry_Request struct { + Publishedfileid *uint64 `protobuf:"fixed64,1,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + Timestamp *uint32 `protobuf:"varint,2,opt,name=timestamp" json:"timestamp,omitempty"` + Language *int32 `protobuf:"varint,3,opt,name=language" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetChangeHistoryEntry_Request) Reset() { + *m = CPublishedFile_GetChangeHistoryEntry_Request{} +} +func (m *CPublishedFile_GetChangeHistoryEntry_Request) String() string { + return proto.CompactTextString(m) +} +func (*CPublishedFile_GetChangeHistoryEntry_Request) ProtoMessage() {} +func (*CPublishedFile_GetChangeHistoryEntry_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{17} +} + +func (m *CPublishedFile_GetChangeHistoryEntry_Request) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *CPublishedFile_GetChangeHistoryEntry_Request) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CPublishedFile_GetChangeHistoryEntry_Request) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return 0 +} + +type CPublishedFile_GetChangeHistoryEntry_Response struct { + ChangeDescription *string `protobuf:"bytes,1,opt,name=change_description" json:"change_description,omitempty"` + Language *int32 `protobuf:"varint,2,opt,name=language" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetChangeHistoryEntry_Response) Reset() { + *m = CPublishedFile_GetChangeHistoryEntry_Response{} +} +func (m *CPublishedFile_GetChangeHistoryEntry_Response) String() string { + return proto.CompactTextString(m) +} +func (*CPublishedFile_GetChangeHistoryEntry_Response) ProtoMessage() {} +func (*CPublishedFile_GetChangeHistoryEntry_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{18} +} + +func (m *CPublishedFile_GetChangeHistoryEntry_Response) GetChangeDescription() string { + if m != nil && m.ChangeDescription != nil { + return *m.ChangeDescription + } + return "" +} + +func (m *CPublishedFile_GetChangeHistoryEntry_Response) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return 0 +} + +type CPublishedFile_GetChangeHistory_Request struct { + Publishedfileid *uint64 `protobuf:"fixed64,1,opt,name=publishedfileid" json:"publishedfileid,omitempty"` + TotalOnly *bool `protobuf:"varint,2,opt,name=total_only" json:"total_only,omitempty"` + Startindex *uint32 `protobuf:"varint,3,opt,name=startindex" json:"startindex,omitempty"` + Count *uint32 `protobuf:"varint,4,opt,name=count" json:"count,omitempty"` + Language *int32 `protobuf:"varint,5,opt,name=language,def=0" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetChangeHistory_Request) Reset() { + *m = CPublishedFile_GetChangeHistory_Request{} +} +func (m *CPublishedFile_GetChangeHistory_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetChangeHistory_Request) ProtoMessage() {} +func (*CPublishedFile_GetChangeHistory_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{19} +} + +const Default_CPublishedFile_GetChangeHistory_Request_Language int32 = 0 + +func (m *CPublishedFile_GetChangeHistory_Request) GetPublishedfileid() uint64 { + if m != nil && m.Publishedfileid != nil { + return *m.Publishedfileid + } + return 0 +} + +func (m *CPublishedFile_GetChangeHistory_Request) GetTotalOnly() bool { + if m != nil && m.TotalOnly != nil { + return *m.TotalOnly + } + return false +} + +func (m *CPublishedFile_GetChangeHistory_Request) GetStartindex() uint32 { + if m != nil && m.Startindex != nil { + return *m.Startindex + } + return 0 +} + +func (m *CPublishedFile_GetChangeHistory_Request) GetCount() uint32 { + if m != nil && m.Count != nil { + return *m.Count + } + return 0 +} + +func (m *CPublishedFile_GetChangeHistory_Request) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return Default_CPublishedFile_GetChangeHistory_Request_Language +} + +type CPublishedFile_GetChangeHistory_Response struct { + Changes []*CPublishedFile_GetChangeHistory_Response_ChangeLog `protobuf:"bytes,1,rep,name=changes" json:"changes,omitempty"` + Total *uint32 `protobuf:"varint,2,opt,name=total" json:"total,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetChangeHistory_Response) Reset() { + *m = CPublishedFile_GetChangeHistory_Response{} +} +func (m *CPublishedFile_GetChangeHistory_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_GetChangeHistory_Response) ProtoMessage() {} +func (*CPublishedFile_GetChangeHistory_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{20} +} + +func (m *CPublishedFile_GetChangeHistory_Response) GetChanges() []*CPublishedFile_GetChangeHistory_Response_ChangeLog { + if m != nil { + return m.Changes + } + return nil +} + +func (m *CPublishedFile_GetChangeHistory_Response) GetTotal() uint32 { + if m != nil && m.Total != nil { + return *m.Total + } + return 0 +} + +type CPublishedFile_GetChangeHistory_Response_ChangeLog struct { + Timestamp *uint32 `protobuf:"varint,1,opt,name=timestamp" json:"timestamp,omitempty"` + ChangeDescription *string `protobuf:"bytes,2,opt,name=change_description" json:"change_description,omitempty"` + Language *int32 `protobuf:"varint,3,opt,name=language" json:"language,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_GetChangeHistory_Response_ChangeLog) Reset() { + *m = CPublishedFile_GetChangeHistory_Response_ChangeLog{} +} +func (m *CPublishedFile_GetChangeHistory_Response_ChangeLog) String() string { + return proto.CompactTextString(m) +} +func (*CPublishedFile_GetChangeHistory_Response_ChangeLog) ProtoMessage() {} +func (*CPublishedFile_GetChangeHistory_Response_ChangeLog) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{20, 0} +} + +func (m *CPublishedFile_GetChangeHistory_Response_ChangeLog) GetTimestamp() uint32 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *CPublishedFile_GetChangeHistory_Response_ChangeLog) GetChangeDescription() string { + if m != nil && m.ChangeDescription != nil { + return *m.ChangeDescription + } + return "" +} + +func (m *CPublishedFile_GetChangeHistory_Response_ChangeLog) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return 0 +} + +type CPublishedFile_RefreshVotingQueue_Request struct { + Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"` + MatchingFileType *uint32 `protobuf:"varint,2,opt,name=matching_file_type" json:"matching_file_type,omitempty"` + Tags []string `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"` + MatchAllTags *bool `protobuf:"varint,4,opt,name=match_all_tags,def=1" json:"match_all_tags,omitempty"` + ExcludedTags []string `protobuf:"bytes,5,rep,name=excluded_tags" json:"excluded_tags,omitempty"` + DesiredQueueSize *uint32 `protobuf:"varint,6,opt,name=desired_queue_size" json:"desired_queue_size,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_RefreshVotingQueue_Request) Reset() { + *m = CPublishedFile_RefreshVotingQueue_Request{} +} +func (m *CPublishedFile_RefreshVotingQueue_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_RefreshVotingQueue_Request) ProtoMessage() {} +func (*CPublishedFile_RefreshVotingQueue_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{21} +} + +const Default_CPublishedFile_RefreshVotingQueue_Request_MatchAllTags bool = true + +func (m *CPublishedFile_RefreshVotingQueue_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_RefreshVotingQueue_Request) GetMatchingFileType() uint32 { + if m != nil && m.MatchingFileType != nil { + return *m.MatchingFileType + } + return 0 +} + +func (m *CPublishedFile_RefreshVotingQueue_Request) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *CPublishedFile_RefreshVotingQueue_Request) GetMatchAllTags() bool { + if m != nil && m.MatchAllTags != nil { + return *m.MatchAllTags + } + return Default_CPublishedFile_RefreshVotingQueue_Request_MatchAllTags +} + +func (m *CPublishedFile_RefreshVotingQueue_Request) GetExcludedTags() []string { + if m != nil { + return m.ExcludedTags + } + return nil +} + +func (m *CPublishedFile_RefreshVotingQueue_Request) GetDesiredQueueSize() uint32 { + if m != nil && m.DesiredQueueSize != nil { + return *m.DesiredQueueSize + } + return 0 +} + +type CPublishedFile_RefreshVotingQueue_Response struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_RefreshVotingQueue_Response) Reset() { + *m = CPublishedFile_RefreshVotingQueue_Response{} +} +func (m *CPublishedFile_RefreshVotingQueue_Response) String() string { + return proto.CompactTextString(m) +} +func (*CPublishedFile_RefreshVotingQueue_Response) ProtoMessage() {} +func (*CPublishedFile_RefreshVotingQueue_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{22} +} + +type CPublishedFile_QueryFiles_Request struct { + QueryType *uint32 `protobuf:"varint,1,opt,name=query_type" json:"query_type,omitempty"` + Page *uint32 `protobuf:"varint,2,opt,name=page" json:"page,omitempty"` + Numperpage *uint32 `protobuf:"varint,3,opt,name=numperpage,def=1" json:"numperpage,omitempty"` + CreatorAppid *uint32 `protobuf:"varint,4,opt,name=creator_appid" json:"creator_appid,omitempty"` + Appid *uint32 `protobuf:"varint,5,opt,name=appid" json:"appid,omitempty"` + Requiredtags []string `protobuf:"bytes,6,rep,name=requiredtags" json:"requiredtags,omitempty"` + Excludedtags []string `protobuf:"bytes,7,rep,name=excludedtags" json:"excludedtags,omitempty"` + MatchAllTags *bool `protobuf:"varint,8,opt,name=match_all_tags,def=1" json:"match_all_tags,omitempty"` + RequiredFlags []string `protobuf:"bytes,9,rep,name=required_flags" json:"required_flags,omitempty"` + OmittedFlags []string `protobuf:"bytes,10,rep,name=omitted_flags" json:"omitted_flags,omitempty"` + SearchText *string `protobuf:"bytes,11,opt,name=search_text" json:"search_text,omitempty"` + Filetype *uint32 `protobuf:"varint,12,opt,name=filetype" json:"filetype,omitempty"` + ChildPublishedfileid *uint64 `protobuf:"fixed64,13,opt,name=child_publishedfileid" json:"child_publishedfileid,omitempty"` + Days *uint32 `protobuf:"varint,14,opt,name=days" json:"days,omitempty"` + IncludeRecentVotesOnly *bool `protobuf:"varint,15,opt,name=include_recent_votes_only" json:"include_recent_votes_only,omitempty"` + CacheMaxAgeSeconds *uint32 `protobuf:"varint,31,opt,name=cache_max_age_seconds,def=0" json:"cache_max_age_seconds,omitempty"` + Language *int32 `protobuf:"varint,33,opt,name=language,def=0" json:"language,omitempty"` + RequiredKvTags []*CPublishedFile_QueryFiles_Request_KVTag `protobuf:"bytes,34,rep,name=required_kv_tags" json:"required_kv_tags,omitempty"` + Totalonly *bool `protobuf:"varint,16,opt,name=totalonly" json:"totalonly,omitempty"` + ReturnVoteData *bool `protobuf:"varint,17,opt,name=return_vote_data" json:"return_vote_data,omitempty"` + ReturnTags *bool `protobuf:"varint,18,opt,name=return_tags" json:"return_tags,omitempty"` + ReturnKvTags *bool `protobuf:"varint,19,opt,name=return_kv_tags" json:"return_kv_tags,omitempty"` + ReturnPreviews *bool `protobuf:"varint,20,opt,name=return_previews" json:"return_previews,omitempty"` + ReturnChildren *bool `protobuf:"varint,21,opt,name=return_children" json:"return_children,omitempty"` + ReturnShortDescription *bool `protobuf:"varint,22,opt,name=return_short_description" json:"return_short_description,omitempty"` + ReturnForSaleData *bool `protobuf:"varint,30,opt,name=return_for_sale_data" json:"return_for_sale_data,omitempty"` + ReturnMetadata *bool `protobuf:"varint,32,opt,name=return_metadata,def=0" json:"return_metadata,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_QueryFiles_Request) Reset() { *m = CPublishedFile_QueryFiles_Request{} } +func (m *CPublishedFile_QueryFiles_Request) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_QueryFiles_Request) ProtoMessage() {} +func (*CPublishedFile_QueryFiles_Request) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{23} +} + +const Default_CPublishedFile_QueryFiles_Request_Numperpage uint32 = 1 +const Default_CPublishedFile_QueryFiles_Request_MatchAllTags bool = true +const Default_CPublishedFile_QueryFiles_Request_CacheMaxAgeSeconds uint32 = 0 +const Default_CPublishedFile_QueryFiles_Request_Language int32 = 0 +const Default_CPublishedFile_QueryFiles_Request_ReturnMetadata bool = false + +func (m *CPublishedFile_QueryFiles_Request) GetQueryType() uint32 { + if m != nil && m.QueryType != nil { + return *m.QueryType + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Request) GetPage() uint32 { + if m != nil && m.Page != nil { + return *m.Page + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Request) GetNumperpage() uint32 { + if m != nil && m.Numperpage != nil { + return *m.Numperpage + } + return Default_CPublishedFile_QueryFiles_Request_Numperpage +} + +func (m *CPublishedFile_QueryFiles_Request) GetCreatorAppid() uint32 { + if m != nil && m.CreatorAppid != nil { + return *m.CreatorAppid + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Request) GetAppid() uint32 { + if m != nil && m.Appid != nil { + return *m.Appid + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Request) GetRequiredtags() []string { + if m != nil { + return m.Requiredtags + } + return nil +} + +func (m *CPublishedFile_QueryFiles_Request) GetExcludedtags() []string { + if m != nil { + return m.Excludedtags + } + return nil +} + +func (m *CPublishedFile_QueryFiles_Request) GetMatchAllTags() bool { + if m != nil && m.MatchAllTags != nil { + return *m.MatchAllTags + } + return Default_CPublishedFile_QueryFiles_Request_MatchAllTags +} + +func (m *CPublishedFile_QueryFiles_Request) GetRequiredFlags() []string { + if m != nil { + return m.RequiredFlags + } + return nil +} + +func (m *CPublishedFile_QueryFiles_Request) GetOmittedFlags() []string { + if m != nil { + return m.OmittedFlags + } + return nil +} + +func (m *CPublishedFile_QueryFiles_Request) GetSearchText() string { + if m != nil && m.SearchText != nil { + return *m.SearchText + } + return "" +} + +func (m *CPublishedFile_QueryFiles_Request) GetFiletype() uint32 { + if m != nil && m.Filetype != nil { + return *m.Filetype + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Request) GetChildPublishedfileid() uint64 { + if m != nil && m.ChildPublishedfileid != nil { + return *m.ChildPublishedfileid + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Request) GetDays() uint32 { + if m != nil && m.Days != nil { + return *m.Days + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Request) GetIncludeRecentVotesOnly() bool { + if m != nil && m.IncludeRecentVotesOnly != nil { + return *m.IncludeRecentVotesOnly + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetCacheMaxAgeSeconds() uint32 { + if m != nil && m.CacheMaxAgeSeconds != nil { + return *m.CacheMaxAgeSeconds + } + return Default_CPublishedFile_QueryFiles_Request_CacheMaxAgeSeconds +} + +func (m *CPublishedFile_QueryFiles_Request) GetLanguage() int32 { + if m != nil && m.Language != nil { + return *m.Language + } + return Default_CPublishedFile_QueryFiles_Request_Language +} + +func (m *CPublishedFile_QueryFiles_Request) GetRequiredKvTags() []*CPublishedFile_QueryFiles_Request_KVTag { + if m != nil { + return m.RequiredKvTags + } + return nil +} + +func (m *CPublishedFile_QueryFiles_Request) GetTotalonly() bool { + if m != nil && m.Totalonly != nil { + return *m.Totalonly + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnVoteData() bool { + if m != nil && m.ReturnVoteData != nil { + return *m.ReturnVoteData + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnTags() bool { + if m != nil && m.ReturnTags != nil { + return *m.ReturnTags + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnKvTags() bool { + if m != nil && m.ReturnKvTags != nil { + return *m.ReturnKvTags + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnPreviews() bool { + if m != nil && m.ReturnPreviews != nil { + return *m.ReturnPreviews + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnChildren() bool { + if m != nil && m.ReturnChildren != nil { + return *m.ReturnChildren + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnShortDescription() bool { + if m != nil && m.ReturnShortDescription != nil { + return *m.ReturnShortDescription + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnForSaleData() bool { + if m != nil && m.ReturnForSaleData != nil { + return *m.ReturnForSaleData + } + return false +} + +func (m *CPublishedFile_QueryFiles_Request) GetReturnMetadata() bool { + if m != nil && m.ReturnMetadata != nil { + return *m.ReturnMetadata + } + return Default_CPublishedFile_QueryFiles_Request_ReturnMetadata +} + +type CPublishedFile_QueryFiles_Request_KVTag struct { + Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_QueryFiles_Request_KVTag) Reset() { + *m = CPublishedFile_QueryFiles_Request_KVTag{} +} +func (m *CPublishedFile_QueryFiles_Request_KVTag) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_QueryFiles_Request_KVTag) ProtoMessage() {} +func (*CPublishedFile_QueryFiles_Request_KVTag) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{23, 0} +} + +func (m *CPublishedFile_QueryFiles_Request_KVTag) GetKey() string { + if m != nil && m.Key != nil { + return *m.Key + } + return "" +} + +func (m *CPublishedFile_QueryFiles_Request_KVTag) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type CPublishedFile_QueryFiles_Response struct { + Total *uint32 `protobuf:"varint,1,opt,name=total" json:"total,omitempty"` + Publishedfiledetails []*PublishedFileDetails `protobuf:"bytes,2,rep,name=publishedfiledetails" json:"publishedfiledetails,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CPublishedFile_QueryFiles_Response) Reset() { *m = CPublishedFile_QueryFiles_Response{} } +func (m *CPublishedFile_QueryFiles_Response) String() string { return proto.CompactTextString(m) } +func (*CPublishedFile_QueryFiles_Response) ProtoMessage() {} +func (*CPublishedFile_QueryFiles_Response) Descriptor() ([]byte, []int) { + return publishedfile_fileDescriptor0, []int{24} +} + +func (m *CPublishedFile_QueryFiles_Response) GetTotal() uint32 { + if m != nil && m.Total != nil { + return *m.Total + } + return 0 +} + +func (m *CPublishedFile_QueryFiles_Response) GetPublishedfiledetails() []*PublishedFileDetails { + if m != nil { + return m.Publishedfiledetails + } + return nil +} + +func init() { + proto.RegisterType((*CPublishedFile_Subscribe_Request)(nil), "CPublishedFile_Subscribe_Request") + proto.RegisterType((*CPublishedFile_Subscribe_Response)(nil), "CPublishedFile_Subscribe_Response") + proto.RegisterType((*CPublishedFile_Unsubscribe_Request)(nil), "CPublishedFile_Unsubscribe_Request") + proto.RegisterType((*CPublishedFile_Unsubscribe_Response)(nil), "CPublishedFile_Unsubscribe_Response") + proto.RegisterType((*CPublishedFile_CanSubscribe_Request)(nil), "CPublishedFile_CanSubscribe_Request") + proto.RegisterType((*CPublishedFile_CanSubscribe_Response)(nil), "CPublishedFile_CanSubscribe_Response") + proto.RegisterType((*CPublishedFile_Publish_Request)(nil), "CPublishedFile_Publish_Request") + proto.RegisterType((*CPublishedFile_Publish_Response)(nil), "CPublishedFile_Publish_Response") + proto.RegisterType((*CPublishedFile_GetDetails_Request)(nil), "CPublishedFile_GetDetails_Request") + proto.RegisterType((*PublishedFileDetails)(nil), "PublishedFileDetails") + proto.RegisterType((*PublishedFileDetails_Tag)(nil), "PublishedFileDetails.Tag") + proto.RegisterType((*PublishedFileDetails_Preview)(nil), "PublishedFileDetails.Preview") + proto.RegisterType((*PublishedFileDetails_Child)(nil), "PublishedFileDetails.Child") + proto.RegisterType((*PublishedFileDetails_KVTag)(nil), "PublishedFileDetails.KVTag") + proto.RegisterType((*PublishedFileDetails_VoteData)(nil), "PublishedFileDetails.VoteData") + proto.RegisterType((*PublishedFileDetails_ForSaleData)(nil), "PublishedFileDetails.ForSaleData") + proto.RegisterType((*CPublishedFile_GetDetails_Response)(nil), "CPublishedFile_GetDetails_Response") + proto.RegisterType((*CPublishedFile_GetItemInfo_Request)(nil), "CPublishedFile_GetItemInfo_Request") + proto.RegisterType((*CPublishedFile_GetItemInfo_Request_WorkshopItem)(nil), "CPublishedFile_GetItemInfo_Request.WorkshopItem") + proto.RegisterType((*CPublishedFile_GetItemInfo_Response)(nil), "CPublishedFile_GetItemInfo_Response") + proto.RegisterType((*CPublishedFile_GetItemInfo_Response_WorkshopItemInfo)(nil), "CPublishedFile_GetItemInfo_Response.WorkshopItemInfo") + proto.RegisterType((*CPublishedFile_GetUserFiles_Request)(nil), "CPublishedFile_GetUserFiles_Request") + proto.RegisterType((*CPublishedFile_GetUserFiles_Request_KVTag)(nil), "CPublishedFile_GetUserFiles_Request.KVTag") + proto.RegisterType((*CPublishedFile_GetUserFiles_Response)(nil), "CPublishedFile_GetUserFiles_Response") + proto.RegisterType((*CPublishedFile_GetUserFiles_Response_App)(nil), "CPublishedFile_GetUserFiles_Response.App") + proto.RegisterType((*CPublishedFile_Update_Request)(nil), "CPublishedFile_Update_Request") + proto.RegisterType((*CPublishedFile_Update_Response)(nil), "CPublishedFile_Update_Response") + proto.RegisterType((*CPublishedFile_GetChangeHistoryEntry_Request)(nil), "CPublishedFile_GetChangeHistoryEntry_Request") + proto.RegisterType((*CPublishedFile_GetChangeHistoryEntry_Response)(nil), "CPublishedFile_GetChangeHistoryEntry_Response") + proto.RegisterType((*CPublishedFile_GetChangeHistory_Request)(nil), "CPublishedFile_GetChangeHistory_Request") + proto.RegisterType((*CPublishedFile_GetChangeHistory_Response)(nil), "CPublishedFile_GetChangeHistory_Response") + proto.RegisterType((*CPublishedFile_GetChangeHistory_Response_ChangeLog)(nil), "CPublishedFile_GetChangeHistory_Response.ChangeLog") + proto.RegisterType((*CPublishedFile_RefreshVotingQueue_Request)(nil), "CPublishedFile_RefreshVotingQueue_Request") + proto.RegisterType((*CPublishedFile_RefreshVotingQueue_Response)(nil), "CPublishedFile_RefreshVotingQueue_Response") + proto.RegisterType((*CPublishedFile_QueryFiles_Request)(nil), "CPublishedFile_QueryFiles_Request") + proto.RegisterType((*CPublishedFile_QueryFiles_Request_KVTag)(nil), "CPublishedFile_QueryFiles_Request.KVTag") + proto.RegisterType((*CPublishedFile_QueryFiles_Response)(nil), "CPublishedFile_QueryFiles_Response") + proto.RegisterEnum("PublishedFileDetails_EPublishedFileForSaleStatus", PublishedFileDetails_EPublishedFileForSaleStatus_name, PublishedFileDetails_EPublishedFileForSaleStatus_value) +} + +var publishedfile_fileDescriptor0 = []byte{ + // 4973 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x5b, 0x4b, 0x70, 0x1b, 0x47, + 0x7a, 0x0e, 0xf8, 0x66, 0x53, 0x14, 0xa9, 0x31, 0x69, 0x43, 0xd0, 0x4a, 0x1a, 0x41, 0x92, 0x45, + 0x4a, 0xd4, 0x58, 0x0f, 0xcb, 0x92, 0x69, 0x7b, 0x6d, 0x41, 0x24, 0x6d, 0xda, 0x7a, 0x50, 0x24, + 0xa5, 0xb5, 0xe3, 0xdd, 0x9d, 0x1d, 0x62, 0x1a, 0xc4, 0x98, 0x03, 0x0c, 0x3c, 0x3d, 0x20, 0x8d, + 0x3d, 0x39, 0x5b, 0x95, 0xa4, 0x6a, 0x93, 0x54, 0x25, 0x95, 0x4a, 0x2a, 0xa7, 0x9c, 0x92, 0x7b, + 0x2e, 0xa9, 0x4a, 0x55, 0x2e, 0x39, 0xe6, 0x90, 0x5c, 0x72, 0xcc, 0x35, 0x95, 0x63, 0x0e, 0xb9, + 0xe4, 0x9c, 0xff, 0xff, 0xbb, 0x7b, 0x30, 0x2f, 0x90, 0x90, 0x1f, 0x7b, 0xd8, 0xb5, 0xd8, 0x8f, + 0xaf, 0xff, 0xee, 0xfe, 0x9f, 0x5f, 0x0f, 0xd8, 0x4d, 0x11, 0x71, 0xa7, 0xd5, 0xe2, 0x42, 0x38, + 0xfb, 0x5c, 0xd8, 0x9d, 0xee, 0x9e, 0xef, 0x89, 0x26, 0x77, 0x1b, 0x9e, 0xcf, 0x2d, 0xea, 0xab, + 0xfb, 0x1e, 0x6f, 0x47, 0x56, 0x27, 0x0c, 0xa2, 0xa0, 0xb2, 0x92, 0x1e, 0xde, 0x6d, 0x7b, 0x0d, + 0x8f, 0xbb, 0xf6, 0x9e, 0x23, 0x0a, 0x46, 0x57, 0x23, 0x66, 0x3e, 0xda, 0xd2, 0x88, 0x1b, 0x80, + 0x68, 0xef, 0x74, 0xf7, 0x44, 0x3d, 0xf4, 0xf6, 0xb8, 0xbd, 0xcd, 0xbf, 0xee, 0x72, 0x11, 0x19, + 0x6f, 0xb0, 0xb9, 0xd4, 0xa2, 0x9e, 0x5b, 0x2e, 0x99, 0xa5, 0xa5, 0x31, 0xe3, 0x0c, 0x9b, 0x86, + 0xd6, 0xc8, 0x8e, 0x7a, 0x1d, 0x5e, 0x1e, 0x81, 0xa6, 0x59, 0x63, 0x96, 0x8d, 0x3b, 0x9d, 0x0e, + 0x8c, 0x18, 0x85, 0x3f, 0xc7, 0x8d, 0x45, 0x36, 0xdb, 0x0e, 0x22, 0xaf, 0xd1, 0xb3, 0xe5, 0xaa, + 0xe5, 0x31, 0x68, 0x9e, 0xaa, 0x5e, 0x66, 0x97, 0x8e, 0x59, 0x55, 0x74, 0x82, 0xb6, 0xe0, 0xd5, + 0x43, 0x56, 0xcd, 0x0c, 0x7a, 0xd1, 0x16, 0xbf, 0x03, 0xe1, 0xae, 0xb2, 0xcb, 0xc7, 0xae, 0xab, + 0xc4, 0xfb, 0x69, 0x6e, 0xd8, 0x23, 0xa7, 0x3d, 0xfc, 0xe1, 0x55, 0x3f, 0x60, 0x57, 0x8e, 0x9f, + 0x2f, 0xd7, 0x41, 0x29, 0xeb, 0x4e, 0xdb, 0x8e, 0x25, 0xa0, 0xe9, 0x53, 0xd5, 0x7f, 0x63, 0xec, + 0x42, 0x66, 0xbe, 0xfa, 0x2b, 0x5e, 0xfa, 0x7d, 0xbd, 0x5d, 0x9c, 0x31, 0x5b, 0xbb, 0xf9, 0x9b, + 0x7f, 0x2c, 0x2f, 0x3f, 0xec, 0x74, 0xcc, 0x4d, 0xd7, 0x8c, 0x9a, 0x9e, 0x30, 0x51, 0x1c, 0x13, + 0xfe, 0xbb, 0xc7, 0xbd, 0xf6, 0xbe, 0x19, 0x4b, 0x69, 0x6e, 0x6c, 0x3f, 0x7b, 0x62, 0x19, 0x8f, + 0xd8, 0xe9, 0x3a, 0x08, 0xd0, 0x6d, 0xf1, 0xd0, 0x96, 0x30, 0x74, 0x88, 0xb5, 0x1b, 0x00, 0x73, + 0x6d, 0x18, 0x98, 0xdd, 0x67, 0x96, 0xf1, 0x19, 0x08, 0xef, 0x07, 0x5d, 0xda, 0x79, 0xdb, 0x69, + 0x71, 0x3a, 0xf9, 0xe9, 0xda, 0xdb, 0x80, 0x71, 0xeb, 0x29, 0xfc, 0x6d, 0x06, 0x0d, 0x00, 0xe1, + 0x12, 0x23, 0x0a, 0xf4, 0x6c, 0xd3, 0x6b, 0x53, 0x73, 0x57, 0xf0, 0xf0, 0x9a, 0x30, 0x09, 0xc2, + 0x32, 0xbe, 0x64, 0x8b, 0x9d, 0x90, 0x1f, 0x7a, 0xfc, 0xc8, 0x4e, 0x83, 0x8e, 0x11, 0xe8, 0xfb, + 0x00, 0xfa, 0xa0, 0x08, 0x14, 0x50, 0x4c, 0x47, 0x50, 0x53, 0x5f, 0x3a, 0xec, 0x04, 0x68, 0x05, + 0x68, 0x19, 0xf7, 0xd8, 0x78, 0xe4, 0x45, 0x3e, 0x2f, 0x8f, 0x13, 0xd8, 0x9b, 0x00, 0x56, 0xdd, + 0xe5, 0xdf, 0x44, 0x26, 0xb5, 0x9a, 0x8d, 0x20, 0x2c, 0x00, 0xb0, 0x8c, 0x0d, 0x36, 0x8f, 0xff, + 0xb0, 0x5d, 0x8e, 0xb7, 0xd3, 0x89, 0xbc, 0xa0, 0x5d, 0x9e, 0x20, 0x84, 0x15, 0x40, 0x58, 0x22, + 0x84, 0x44, 0xdf, 0x40, 0x9c, 0xc7, 0x6c, 0x9a, 0x70, 0x48, 0x5b, 0x27, 0xe9, 0xa0, 0xdf, 0x05, + 0x80, 0x7b, 0x4b, 0xeb, 0x3f, 0x0b, 0xc2, 0x03, 0xd1, 0x0c, 0x3a, 0x78, 0xc5, 0xbb, 0xd0, 0xbb, + 0x6c, 0xe2, 0xff, 0xe3, 0x1e, 0x75, 0x4f, 0xf6, 0xf4, 0x2c, 0x63, 0x93, 0xbd, 0x1e, 0xdf, 0x1d, + 0x8c, 0x08, 0xa3, 0x7a, 0x37, 0xb2, 0xe9, 0xa8, 0xa6, 0x48, 0xb6, 0x65, 0x80, 0xbe, 0xba, 0xa3, + 0x3a, 0x4c, 0xec, 0x18, 0x28, 0xd8, 0x26, 0x9b, 0xef, 0x05, 0xdd, 0xa8, 0x0b, 0x2a, 0x89, 0xb7, + 0x41, 0x20, 0xd3, 0x04, 0xf2, 0x16, 0x80, 0xdc, 0x58, 0x7a, 0x46, 0xfb, 0x72, 0xfc, 0x65, 0xf3, + 0x85, 0xbc, 0xac, 0x2f, 0x82, 0xee, 0x2e, 0x8c, 0x36, 0x9d, 0x7a, 0x3d, 0xe8, 0xb6, 0x23, 0x53, + 0xcf, 0xb2, 0x8c, 0x9f, 0xb3, 0x39, 0x0d, 0x75, 0xe8, 0xb9, 0x3c, 0x00, 0x95, 0x62, 0x84, 0xf4, + 0x08, 0x90, 0x3e, 0x4c, 0x20, 0xbd, 0xc4, 0x5e, 0xd4, 0x2f, 0xd8, 0xa4, 0x13, 0x03, 0xd2, 0x1c, + 0x25, 0x27, 0xa8, 0x5b, 0x56, 0xd0, 0x3f, 0x28, 0x31, 0x76, 0xe8, 0x09, 0x6f, 0xcf, 0xf3, 0xbd, + 0xa8, 0x57, 0x9e, 0xa1, 0x33, 0x6c, 0x01, 0xb2, 0xb7, 0xb4, 0xbe, 0xcd, 0x5b, 0x41, 0xc4, 0x77, + 0xa2, 0x20, 0x04, 0x9f, 0x98, 0x32, 0x9a, 0x97, 0xf1, 0x0c, 0x5c, 0x56, 0xff, 0x5b, 0x6b, 0x50, + 0x7a, 0x0d, 0x73, 0xa9, 0x13, 0x7a, 0x87, 0x4e, 0xc4, 0x57, 0xcc, 0x46, 0x08, 0x0e, 0xc3, 0x15, + 0x2b, 0x72, 0x44, 0x7d, 0xc5, 0xe4, 0x51, 0xdd, 0x5a, 0x36, 0x0e, 0xd8, 0xa9, 0x90, 0xbb, 0x5e, + 0xc8, 0xeb, 0x91, 0xdd, 0x0d, 0xbd, 0xf2, 0x29, 0xda, 0xde, 0x0b, 0x10, 0xe2, 0x79, 0x62, 0x7b, + 0x9b, 0x0d, 0x53, 0x74, 0x3b, 0x1d, 0xf0, 0x39, 0xee, 0x0a, 0x2d, 0x13, 0x72, 0xd1, 0xf5, 0xa3, + 0xb4, 0xf5, 0x28, 0xfd, 0x84, 0x43, 0x80, 0xbd, 0x82, 0xfd, 0xc1, 0x72, 0xd0, 0x0a, 0x97, 0x8c, + 0x13, 0x5e, 0x6c, 0x6f, 0x5a, 0xc6, 0x1a, 0x1b, 0x8b, 0x9c, 0x7d, 0x51, 0x9e, 0x35, 0x47, 0x61, + 0x91, 0x77, 0x60, 0x91, 0x3b, 0x0f, 0xc3, 0xd0, 0x91, 0xc2, 0x93, 0xe6, 0x42, 0x2f, 0xce, 0x80, + 0xd9, 0x7e, 0x4f, 0x4f, 0xcd, 0x1e, 0xdb, 0x17, 0x6c, 0xae, 0x1e, 0xf8, 0x3e, 0x48, 0x0c, 0xd2, + 0x49, 0xf5, 0x3b, 0x4d, 0x52, 0x7f, 0x04, 0x80, 0xef, 0x27, 0xa4, 0xd6, 0x5a, 0xd7, 0x1f, 0x5d, + 0x74, 0x44, 0x21, 0x07, 0x8b, 0x12, 0xe0, 0x4c, 0x85, 0x65, 0x3c, 0x61, 0xd3, 0xfb, 0x70, 0xf1, + 0x12, 0x74, 0x8e, 0x40, 0x57, 0x01, 0xf4, 0x9d, 0x02, 0x50, 0x1c, 0x77, 0x12, 0xdc, 0x97, 0x6c, + 0xb4, 0x1b, 0xfa, 0xe5, 0x79, 0x02, 0x7a, 0x0a, 0x40, 0x9f, 0xa6, 0xcf, 0x94, 0xb4, 0xa2, 0x3f, + 0x01, 0x34, 0x07, 0x51, 0x57, 0x64, 0xbb, 0x27, 0xd4, 0xc1, 0x3d, 0x96, 0x07, 0xe1, 0x44, 0xd4, + 0x8b, 0x1e, 0x00, 0x54, 0xc2, 0xaa, 0x6e, 0xb1, 0x8b, 0x03, 0xbd, 0xa9, 0x72, 0xc4, 0x03, 0x23, + 0xcd, 0x42, 0xe6, 0xd6, 0xd1, 0x4f, 0x4e, 0x57, 0xff, 0x67, 0x22, 0x17, 0xe4, 0x3e, 0xe6, 0xd1, + 0x1a, 0x8f, 0x1c, 0xcf, 0x17, 0xb1, 0x8f, 0xde, 0x62, 0xf3, 0x19, 0x50, 0x01, 0xa8, 0xa3, 0x4b, + 0x13, 0xf2, 0x42, 0x77, 0x78, 0x84, 0xc7, 0x93, 0x39, 0x95, 0x4d, 0x97, 0xee, 0x35, 0xe4, 0x11, + 0xa8, 0xe1, 0x21, 0x07, 0x07, 0x43, 0xa0, 0x68, 0x1b, 0x96, 0xf1, 0x9c, 0xcd, 0x78, 0xed, 0xba, + 0xdf, 0xc5, 0x46, 0xd0, 0x0e, 0x14, 0x66, 0x4a, 0xfa, 0x46, 0x3c, 0xa3, 0xb0, 0x0b, 0x27, 0x02, + 0x13, 0xbb, 0x61, 0x1b, 0xf5, 0x03, 0x1c, 0x2d, 0x4c, 0x6a, 0x39, 0x74, 0x9d, 0xca, 0xe9, 0xca, + 0x5e, 0x58, 0x4b, 0xc1, 0x5a, 0x46, 0x9d, 0x9d, 0x55, 0x90, 0x8e, 0xeb, 0x7a, 0xf2, 0xc8, 0x95, + 0xe3, 0x14, 0xe4, 0xd1, 0xa7, 0xa4, 0xb6, 0x64, 0x17, 0x50, 0x63, 0x86, 0x5b, 0xe4, 0x29, 0x9b, + 0x53, 0x8b, 0xd4, 0x9b, 0x9e, 0xef, 0x86, 0xbc, 0x2d, 0xe3, 0x71, 0xed, 0x1e, 0x40, 0xdf, 0xce, + 0x42, 0xeb, 0x31, 0x83, 0xf1, 0xb6, 0xd9, 0xac, 0xc2, 0x3b, 0x38, 0xa4, 0x93, 0x18, 0x27, 0xb4, + 0xf7, 0x00, 0xed, 0x7e, 0x16, 0xed, 0x80, 0xf7, 0xcc, 0x43, 0xc7, 0xef, 0x72, 0x69, 0x33, 0x03, + 0x31, 0x1f, 0xb3, 0x53, 0x0a, 0xf3, 0x10, 0xfc, 0x89, 0x20, 0x4f, 0x3f, 0x25, 0x6f, 0x2a, 0x0b, + 0x89, 0x03, 0x4c, 0xd7, 0x89, 0x9c, 0xe3, 0x8e, 0xf5, 0x0c, 0x39, 0xe7, 0x54, 0xf0, 0x98, 0x22, + 0xc8, 0x4f, 0x00, 0x72, 0x2d, 0x0b, 0xe9, 0x98, 0x34, 0x3c, 0x15, 0x4f, 0xbc, 0x36, 0xe6, 0x74, + 0x6e, 0x1c, 0xf2, 0xba, 0xbe, 0x9f, 0xec, 0x47, 0x91, 0x0d, 0x25, 0x32, 0xdc, 0x81, 0x70, 0x7c, + 0x8e, 0x32, 0x91, 0xdf, 0x9d, 0xaa, 0xdd, 0x82, 0x55, 0x56, 0xf2, 0x97, 0xe6, 0xd5, 0xd1, 0x15, + 0xe1, 0xb8, 0x15, 0xd3, 0x6b, 0x90, 0xfb, 0xf0, 0xea, 0xce, 0x1e, 0x7a, 0x8b, 0x5a, 0x7c, 0x49, + 0x2d, 0xd8, 0x05, 0x41, 0xcd, 0x10, 0x14, 0x45, 0x94, 0x18, 0xaa, 0x13, 0x74, 0xba, 0x3e, 0x38, + 0x4a, 0x92, 0x49, 0x8f, 0x04, 0xdd, 0xe5, 0x3e, 0x84, 0xf1, 0x17, 0x6c, 0xca, 0x77, 0xda, 0xfb, + 0x5d, 0xb0, 0x3b, 0x72, 0x90, 0xe3, 0xab, 0xa5, 0x5b, 0x52, 0x7f, 0x76, 0x3a, 0xbc, 0x8e, 0xd9, + 0xaa, 0xb4, 0x55, 0x3f, 0xa8, 0x3b, 0xbe, 0xf7, 0x6b, 0xf4, 0x7a, 0xe4, 0xcd, 0x02, 0x25, 0xa1, + 0x65, 0xae, 0xf1, 0x86, 0x03, 0x0e, 0x93, 0x8c, 0x60, 0xbd, 0xbd, 0x4f, 0x31, 0xaf, 0xfa, 0xdf, + 0xaf, 0xb1, 0x85, 0x94, 0xb9, 0x29, 0x53, 0x33, 0x4e, 0xb3, 0x09, 0xe9, 0x60, 0x65, 0x1e, 0x54, + 0x64, 0xc7, 0x23, 0x64, 0xc7, 0x73, 0x6c, 0xb2, 0x1e, 0x72, 0x07, 0xa2, 0x04, 0x29, 0xf5, 0x04, + 0xa5, 0x5e, 0xb2, 0x41, 0x65, 0x40, 0x63, 0x04, 0xf0, 0x7a, 0x2e, 0x33, 0x1a, 0xa7, 0xf6, 0x73, + 0xec, 0xb5, 0x5c, 0xd4, 0x85, 0xce, 0x09, 0xea, 0x9c, 0x67, 0x53, 0x71, 0xbe, 0x82, 0xf1, 0x7d, + 0x1a, 0x13, 0x54, 0x0a, 0xf9, 0x02, 0xf6, 0x48, 0xd7, 0x3e, 0x66, 0x9c, 0x65, 0x67, 0x74, 0x86, + 0xd3, 0xef, 0x9a, 0xa6, 0x2e, 0x35, 0xdf, 0x46, 0x17, 0x48, 0x51, 0xd3, 0x78, 0x8d, 0xcd, 0xe8, + 0xc1, 0xd8, 0x38, 0x43, 0x8d, 0x20, 0x9b, 0x8a, 0xb1, 0x3a, 0xc4, 0x52, 0x0c, 0x32, 0x66, 0xa4, + 0xf3, 0x9c, 0xa5, 0x3f, 0x60, 0x5f, 0x4d, 0x90, 0x34, 0x02, 0x37, 0x49, 0xeb, 0x90, 0xc7, 0x9f, + 0x30, 0xca, 0x6c, 0x3e, 0x6e, 0x56, 0xc8, 0xe4, 0xb6, 0x27, 0x30, 0x71, 0x96, 0xc9, 0x11, 0x39, + 0x5f, 0x1c, 0x98, 0x4b, 0x7a, 0xce, 0x50, 0xcf, 0xd9, 0x22, 0x95, 0x36, 0xa8, 0x0b, 0xbc, 0x64, + 0xe4, 0x41, 0x34, 0xa0, 0x13, 0xe5, 0x6e, 0xf9, 0x35, 0x3a, 0x16, 0xdd, 0xda, 0xed, 0xb8, 0xd4, + 0xba, 0x40, 0xad, 0x46, 0x2a, 0x94, 0x2f, 0xea, 0xe4, 0xbd, 0xe1, 0xa3, 0x1d, 0xbf, 0x4e, 0x7f, + 0xc2, 0x1e, 0x8e, 0x54, 0xfe, 0x23, 0xf7, 0xf0, 0x06, 0xea, 0x21, 0x0a, 0x10, 0x37, 0x43, 0x06, + 0xc2, 0x3b, 0x08, 0x5a, 0xa6, 0xae, 0x0a, 0x33, 0xa0, 0xf9, 0xa8, 0x9f, 0x49, 0xdb, 0x8e, 0xef, + 0x97, 0xcf, 0x52, 0xdf, 0x05, 0xf6, 0x7a, 0xbb, 0xdb, 0xb2, 0xeb, 0x01, 0x14, 0x4e, 0x10, 0x3b, + 0x40, 0xfc, 0x43, 0xee, 0x07, 0x1d, 0x1e, 0x96, 0x2b, 0x54, 0x2a, 0xc0, 0xd5, 0xa6, 0xfa, 0x65, + 0xd8, 0x2f, 0x9f, 0xa3, 0x4e, 0x50, 0xb0, 0x3d, 0xa7, 0x0d, 0xa6, 0x5d, 0xfe, 0x09, 0x81, 0x81, + 0xf4, 0xf0, 0xb7, 0x0d, 0xfb, 0x14, 0xb0, 0xfb, 0xf3, 0xb4, 0x7b, 0x3d, 0x26, 0x2c, 0x5f, 0xa0, + 0x13, 0x45, 0x1d, 0x82, 0x31, 0x7b, 0x78, 0x88, 0x3e, 0x47, 0x21, 0x2f, 0xd2, 0xdc, 0x05, 0xf2, + 0x30, 0x41, 0xab, 0x03, 0xde, 0x12, 0x2c, 0xae, 0x6c, 0x52, 0x2b, 0x5c, 0x3e, 0x28, 0x9a, 0xcc, + 0xe0, 0x2e, 0xa5, 0x94, 0x87, 0x62, 0x6b, 0x55, 0x9f, 0x48, 0xba, 0x50, 0xb8, 0x4c, 0x73, 0xa1, + 0x59, 0x35, 0xd1, 0x6d, 0x88, 0xf2, 0x15, 0x1a, 0x8d, 0x00, 0xce, 0x61, 0x10, 0x7a, 0xb8, 0xf6, + 0xd5, 0xb8, 0x09, 0x82, 0x7b, 0x70, 0xc4, 0x43, 0x51, 0x7e, 0x93, 0x9a, 0xe0, 0x5c, 0x7c, 0xaf, + 0xc1, 0xe9, 0x8a, 0xd2, 0x28, 0xd7, 0xa8, 0x1f, 0xce, 0x34, 0xee, 0xef, 0xc3, 0x2d, 0xe5, 0xfb, + 0x62, 0xdc, 0x65, 0x7d, 0x99, 0x32, 0x7a, 0x5c, 0xa7, 0x3f, 0x41, 0x95, 0xbd, 0x16, 0xf8, 0x03, + 0xfb, 0xc8, 0x73, 0xa3, 0x66, 0xf9, 0x86, 0x56, 0x0d, 0xd9, 0xd8, 0xe4, 0xde, 0x7e, 0x33, 0x2a, + 0xaf, 0x68, 0x21, 0x65, 0x2b, 0xaa, 0xf3, 0x4d, 0x6d, 0x08, 0x10, 0xa2, 0xe1, 0x34, 0x42, 0x1b, + 0xdc, 0x77, 0xd9, 0xd2, 0x97, 0x90, 0xb0, 0xc1, 0xb7, 0x34, 0xa2, 0x6e, 0xa3, 0xa3, 0xbc, 0xa5, + 0x15, 0x93, 0xee, 0x56, 0x47, 0x9d, 0xdb, 0x5a, 0x24, 0x6c, 0x85, 0x7c, 0x02, 0x26, 0x88, 0xf2, + 0x1d, 0x6a, 0x7c, 0x8b, 0x4d, 0xc5, 0x71, 0xef, 0x2e, 0x44, 0xe9, 0x99, 0x3b, 0xe7, 0xad, 0x22, + 0x9f, 0x63, 0x6d, 0xc9, 0x51, 0xc6, 0x35, 0x95, 0xa3, 0xbd, 0x4d, 0x83, 0xcf, 0x16, 0x0f, 0xde, + 0x75, 0xf6, 0x8d, 0x9b, 0x6c, 0x2a, 0x16, 0xe0, 0x1e, 0x0d, 0x3e, 0x57, 0x3c, 0xf8, 0x11, 0x8e, + 0x32, 0x6e, 0xb0, 0x09, 0x15, 0xd5, 0xde, 0x39, 0x6e, 0xf0, 0x67, 0x2f, 0x11, 0xfb, 0x36, 0x9b, + 0xc6, 0x68, 0x64, 0x93, 0xbb, 0xbe, 0x0f, 0x1b, 0x99, 0xb9, 0x73, 0xa1, 0x78, 0xfc, 0x4b, 0x18, + 0xb6, 0x06, 0xa3, 0x8c, 0x90, 0xcd, 0x25, 0xef, 0x7c, 0x0f, 0x2e, 0xf5, 0x01, 0x25, 0xd4, 0x5f, + 0x80, 0x9f, 0x7e, 0xf1, 0xac, 0xed, 0x53, 0xbc, 0xf4, 0x5c, 0x0c, 0x6e, 0x29, 0x24, 0x0b, 0x72, + 0x1c, 0x2c, 0x04, 0xf0, 0xdf, 0x90, 0x82, 0xb5, 0x5d, 0x13, 0x4a, 0x6c, 0xf8, 0x1f, 0x84, 0x7f, + 0x3f, 0x3f, 0x52, 0xae, 0x6b, 0x82, 0x9f, 0x07, 0x3f, 0xed, 0xb0, 0x59, 0x08, 0x51, 0x36, 0xc6, + 0x28, 0x29, 0xea, 0xbb, 0x24, 0xea, 0xa5, 0x62, 0x51, 0x37, 0x82, 0x70, 0x07, 0x46, 0xa2, 0xb4, + 0xb5, 0x6b, 0x20, 0xd4, 0xe5, 0x2d, 0x15, 0xb7, 0x12, 0xc9, 0x46, 0x2e, 0x7c, 0xdd, 0x67, 0x53, + 0x71, 0xdc, 0x5a, 0xa5, 0x3c, 0xf2, 0x2a, 0x4c, 0xbd, 0xf4, 0x44, 0x47, 0x28, 0x47, 0x88, 0xa0, + 0xee, 0xa1, 0x23, 0x32, 0x8f, 0xbc, 0xa8, 0x49, 0x61, 0x08, 0x34, 0xba, 0x85, 0xba, 0x9c, 0x34, + 0x4b, 0x70, 0x2d, 0x18, 0x25, 0xde, 0x23, 0x53, 0x06, 0x1b, 0x49, 0xf5, 0xe1, 0xc1, 0x89, 0xc8, + 0x69, 0x75, 0xca, 0xef, 0x93, 0xd2, 0x3c, 0x4a, 0xc4, 0xbb, 0x0f, 0x74, 0xbc, 0xb3, 0x60, 0xdd, + 0xeb, 0xbb, 0x18, 0xe5, 0x54, 0x97, 0x8e, 0xe0, 0xb2, 0xdc, 0xc4, 0x83, 0x4b, 0x86, 0xf1, 0xca, + 0x55, 0x36, 0x8a, 0x57, 0x09, 0x6e, 0x1c, 0x55, 0xbc, 0xa4, 0x7d, 0x80, 0xe3, 0xb6, 0xbc, 0x76, + 0x00, 0xd7, 0x21, 0xf3, 0xbc, 0x4a, 0xc4, 0x26, 0xb5, 0xea, 0x41, 0xaf, 0xd2, 0xd5, 0x24, 0x25, + 0x22, 0x40, 0x9b, 0x83, 0xd0, 0x05, 0x3f, 0x24, 0x29, 0x11, 0x15, 0x17, 0xa8, 0x2c, 0x37, 0x4e, + 0xb1, 0x31, 0x8a, 0x38, 0x63, 0xb9, 0x88, 0x35, 0x3e, 0x20, 0xb8, 0x50, 0xa9, 0x5b, 0xd9, 0x60, + 0xe3, 0x52, 0x2d, 0x8f, 0x23, 0x63, 0xb2, 0x2b, 0xa7, 0x3c, 0x18, 0xae, 0x3f, 0x5b, 0xb9, 0xcc, + 0xc6, 0xa5, 0xc6, 0x82, 0x54, 0x90, 0x92, 0xa9, 0x6d, 0xa2, 0xaf, 0xc0, 0xdc, 0x4c, 0xe6, 0xd5, + 0x95, 0x0f, 0xd9, 0x54, 0xac, 0xa6, 0xd0, 0x25, 0xea, 0x41, 0x28, 0x39, 0x91, 0x11, 0x94, 0x98, + 0xf2, 0x32, 0x88, 0x26, 0x6a, 0x11, 0x0c, 0x24, 0xd4, 0xe2, 0x06, 0x47, 0x6d, 0xb5, 0xca, 0xff, + 0x96, 0xd8, 0x4c, 0x42, 0x7b, 0xc8, 0xf9, 0x08, 0x5b, 0xab, 0x9e, 0xa4, 0x57, 0x70, 0xab, 0x98, + 0x08, 0x41, 0xb8, 0x02, 0x6d, 0xd8, 0x0f, 0xc2, 0x9e, 0x02, 0x7c, 0xc9, 0x26, 0xf1, 0x72, 0xa3, + 0xae, 0x4c, 0x7c, 0x4f, 0xdf, 0xb9, 0x5d, 0xac, 0x9e, 0xeb, 0xa9, 0x56, 0xb5, 0xdc, 0x0e, 0x4d, + 0x5c, 0x35, 0x0e, 0xec, 0xad, 0x8d, 0x8d, 0x9d, 0x1d, 0xfb, 0x69, 0x10, 0xa9, 0x1e, 0xe3, 0x27, + 0x6c, 0x21, 0xbd, 0x9e, 0xdd, 0xf0, 0x03, 0x50, 0x31, 0x79, 0x15, 0x55, 0x56, 0x91, 0xbd, 0x20, + 0x68, 0xc7, 0xe9, 0xd9, 0x47, 0x50, 0xbf, 0xd8, 0x70, 0x15, 0xf6, 0x91, 0xd3, 0x8e, 0x64, 0x62, + 0x8b, 0x21, 0xca, 0xf5, 0x04, 0xd5, 0xdc, 0x36, 0x04, 0xae, 0x3a, 0xc4, 0x29, 0xd4, 0x38, 0xca, + 0x3e, 0xaa, 0xff, 0x5a, 0x62, 0xe7, 0x8e, 0x11, 0x09, 0xb6, 0x5b, 0x20, 0xd4, 0xfc, 0xef, 0x01, + 0xe8, 0x1b, 0xba, 0x7d, 0x0b, 0x2a, 0x50, 0xb0, 0xaf, 0x87, 0x9d, 0x4e, 0x18, 0xc0, 0x7d, 0xcc, + 0x97, 0x92, 0x9d, 0xb2, 0x15, 0x90, 0xd5, 0xcc, 0x91, 0x64, 0xe7, 0x36, 0xff, 0x0a, 0x4a, 0xa3, + 0x7e, 0xe7, 0x68, 0xb2, 0xf3, 0x69, 0xf0, 0x38, 0x68, 0xef, 0x83, 0xc3, 0x50, 0x9d, 0x63, 0xc6, + 0x79, 0x76, 0x56, 0x77, 0xee, 0xe2, 0x26, 0x22, 0xef, 0x90, 0xc7, 0xab, 0x8e, 0x57, 0xbf, 0xc8, + 0xd1, 0x82, 0xa9, 0xb2, 0x4a, 0x15, 0x6b, 0x77, 0xe1, 0x3c, 0x93, 0x9a, 0xa8, 0x92, 0x6e, 0xaa, + 0xad, 0x66, 0xee, 0x2c, 0x16, 0x5e, 0x5a, 0xf5, 0x3f, 0x4b, 0x45, 0xd8, 0x9b, 0xe0, 0x00, 0x36, + 0xc1, 0xa9, 0xc4, 0x35, 0x1b, 0xc4, 0x72, 0x8c, 0xc6, 0x9a, 0x58, 0xc3, 0x9c, 0xc3, 0x77, 0x90, + 0x69, 0x4c, 0x26, 0x32, 0x52, 0x5d, 0x3e, 0x61, 0xa7, 0xe3, 0x74, 0x04, 0x1d, 0x09, 0x6a, 0x0d, + 0x0a, 0x70, 0xcb, 0x3a, 0x79, 0x1d, 0x4b, 0xf3, 0x3b, 0xd8, 0x01, 0x6a, 0x7f, 0x2a, 0xf9, 0x37, + 0xa5, 0x8a, 0x1a, 0x41, 0x26, 0x8b, 0x4a, 0x9e, 0x89, 0x5c, 0x4e, 0x45, 0xa2, 0x54, 0xff, 0xab, + 0x94, 0x23, 0x2c, 0xd3, 0x8b, 0xaa, 0x93, 0x03, 0x73, 0x90, 0x13, 0x69, 0x3f, 0x6a, 0x8b, 0x4f, + 0x72, 0xfb, 0x18, 0xa1, 0x7d, 0xdc, 0xb3, 0x86, 0x80, 0x4c, 0x6d, 0x04, 0x7b, 0x2a, 0x9f, 0xb3, + 0xf9, 0x6c, 0xdb, 0x2b, 0x6f, 0x08, 0x05, 0x6d, 0x39, 0x6d, 0xc8, 0x30, 0xe0, 0xe8, 0x15, 0xa7, + 0x3b, 0x51, 0xfd, 0xbf, 0xf9, 0xa2, 0x5d, 0xc6, 0x11, 0x29, 0xbe, 0xc3, 0x4f, 0xd9, 0x24, 0x91, + 0xe1, 0x7a, 0x0d, 0xc9, 0xb6, 0xed, 0x60, 0x93, 0xb9, 0xb9, 0xa6, 0x9d, 0x31, 0x72, 0x57, 0xe6, + 0x51, 0x33, 0x10, 0x92, 0x4c, 0x84, 0x80, 0x16, 0x72, 0xc5, 0x73, 0x86, 0x12, 0x88, 0xbb, 0xc8, + 0x01, 0x8e, 0x27, 0x09, 0xd2, 0xfb, 0x80, 0x74, 0x57, 0x11, 0xa4, 0x0a, 0x07, 0xba, 0x25, 0xe7, + 0xa0, 0x69, 0x49, 0x61, 0x42, 0x32, 0x94, 0x64, 0x3b, 0xa2, 0xc0, 0x32, 0x56, 0xd9, 0x18, 0x92, + 0x11, 0xd2, 0xe6, 0x57, 0x4b, 0xb7, 0x65, 0x51, 0x95, 0x20, 0x39, 0xc0, 0x58, 0x43, 0x49, 0x13, + 0x61, 0xc0, 0x40, 0x26, 0x4c, 0x16, 0x36, 0x50, 0x4b, 0x6e, 0x31, 0x06, 0xe9, 0x0a, 0xd8, 0x3d, + 0x21, 0x8c, 0x6b, 0x04, 0xc9, 0x21, 0x26, 0xf8, 0x16, 0x58, 0x1f, 0xc6, 0xed, 0xc1, 0xb6, 0x40, + 0x34, 0x35, 0x1b, 0xea, 0x35, 0xf8, 0x9b, 0x30, 0xfb, 0x45, 0x16, 0x84, 0xad, 0x31, 0x72, 0xcd, + 0xe4, 0xe2, 0x57, 0x27, 0x5b, 0x3d, 0x92, 0x5b, 0xd2, 0x9a, 0x05, 0x0c, 0x8e, 0xdc, 0x15, 0xcc, + 0xdf, 0xeb, 0x97, 0xba, 0xc8, 0x2e, 0x31, 0xf4, 0xfb, 0x10, 0x74, 0x9b, 0x81, 0x2b, 0xeb, 0x9e, + 0xd5, 0x19, 0x34, 0x16, 0x75, 0x95, 0xb5, 0x07, 0x00, 0xf7, 0x76, 0x72, 0x8b, 0x81, 0xdc, 0xa1, + 0x9c, 0xa1, 0xd9, 0x5b, 0x28, 0x74, 0xe3, 0xf2, 0x99, 0x62, 0x01, 0xec, 0xf8, 0x3d, 0x36, 0x49, + 0x74, 0x5c, 0xbd, 0x47, 0x15, 0xd2, 0x6c, 0xed, 0x3a, 0x40, 0xbd, 0xb9, 0x14, 0xc4, 0x50, 0x70, + 0xe1, 0x11, 0xec, 0x6b, 0xaf, 0x67, 0xaa, 0x71, 0xa6, 0xe0, 0x11, 0x82, 0xc3, 0xe4, 0x26, 0x52, + 0x36, 0x5f, 0x77, 0xbd, 0x90, 0xbb, 0x94, 0x45, 0x31, 0xe2, 0xd0, 0xb6, 0x01, 0xe1, 0x69, 0x72, + 0x6f, 0x44, 0xa0, 0xe1, 0xbd, 0xb5, 0xba, 0x22, 0xc2, 0x9d, 0x29, 0x72, 0x09, 0x05, 0x72, 0xb2, + 0xac, 0x0c, 0xc8, 0x2a, 0xc0, 0x59, 0x89, 0x46, 0x8f, 0xae, 0x19, 0xd4, 0x23, 0xec, 0x59, 0x86, + 0xcf, 0x4e, 0xf1, 0x6f, 0xa8, 0x62, 0x96, 0x2b, 0xcd, 0xd0, 0x4a, 0x2f, 0x61, 0xa5, 0xed, 0xc1, + 0x2b, 0x3d, 0x7d, 0xb6, 0xfb, 0xdd, 0x56, 0x6b, 0xb3, 0x79, 0xbd, 0x2f, 0xfb, 0xe0, 0xd0, 0xa6, + 0x15, 0x2f, 0x90, 0xa5, 0x5e, 0xb7, 0x86, 0x30, 0x0b, 0x99, 0x30, 0xd6, 0x96, 0x40, 0xba, 0x2b, + 0xdb, 0x0a, 0x07, 0xc9, 0x91, 0x9b, 0x09, 0x72, 0x04, 0x16, 0x86, 0xec, 0xaa, 0xde, 0x34, 0x91, + 0x5d, 0xf8, 0x40, 0xe6, 0x08, 0x31, 0x6d, 0xa8, 0x9e, 0x07, 0x12, 0x3b, 0xdb, 0x20, 0x61, 0x51, + 0x49, 0xe2, 0x89, 0x5a, 0x55, 0x2c, 0x4c, 0xf9, 0xd2, 0x05, 0xf6, 0x1c, 0x61, 0x7c, 0x0a, 0x18, + 0x1b, 0x03, 0x2c, 0x28, 0x61, 0x32, 0xda, 0x96, 0x56, 0x4c, 0xcc, 0x80, 0x24, 0x38, 0xb4, 0x43, + 0xce, 0x27, 0x14, 0x91, 0xe0, 0x22, 0x7f, 0xbd, 0x40, 0x1d, 0xf2, 0xc9, 0xc0, 0x8e, 0x33, 0x1a, + 0x49, 0x23, 0x92, 0xb4, 0x4f, 0x48, 0x2a, 0xa2, 0x09, 0x69, 0x90, 0xa9, 0x07, 0x65, 0xa0, 0xbe, + 0x62, 0x8b, 0x75, 0x07, 0x96, 0xb0, 0x5b, 0xce, 0x37, 0x36, 0x96, 0x20, 0x82, 0x43, 0xb9, 0xec, + 0x0a, 0x2a, 0x03, 0x67, 0x31, 0xab, 0x23, 0xda, 0xe6, 0x21, 0x96, 0x3a, 0x26, 0x24, 0x09, 0xbe, + 0x22, 0x80, 0xd2, 0x46, 0x11, 0x33, 0xed, 0x31, 0x72, 0xc2, 0x22, 0x15, 0x62, 0x9a, 0x24, 0x39, + 0xff, 0x83, 0x91, 0x24, 0x86, 0xc7, 0xa6, 0xa3, 0x00, 0x24, 0xa3, 0x94, 0xf1, 0x0c, 0x31, 0x37, + 0x59, 0x55, 0x8c, 0x49, 0x1c, 0x3a, 0x54, 0x4d, 0x15, 0x62, 0x66, 0x8a, 0x13, 0x13, 0xb2, 0xaa, + 0x6b, 0xc4, 0x4b, 0xe9, 0x6b, 0x22, 0x9c, 0x61, 0xac, 0x8a, 0x53, 0x9e, 0x2b, 0x6c, 0x5a, 0xc9, + 0xa0, 0x95, 0x7e, 0x0e, 0x2b, 0x7d, 0x3e, 0xcc, 0x4a, 0x19, 0x55, 0x07, 0x98, 0x21, 0xd6, 0x7b, + 0x1b, 0x55, 0x1f, 0x21, 0xec, 0x7e, 0xb1, 0x83, 0x1c, 0xc3, 0xd4, 0xea, 0x18, 0xae, 0x52, 0x5b, + 0x80, 0xd5, 0xe7, 0xb7, 0x33, 0xe4, 0x9c, 0xf1, 0x80, 0xcd, 0xa8, 0x59, 0x64, 0x2b, 0x0b, 0x24, + 0xe8, 0x65, 0x18, 0x7a, 0x71, 0x3b, 0x26, 0x49, 0x63, 0x42, 0x90, 0xa4, 0x51, 0x99, 0x84, 0xf1, + 0x19, 0x3b, 0xad, 0x66, 0x6a, 0x43, 0x5b, 0x4c, 0xac, 0x46, 0x8f, 0x6d, 0xdb, 0x31, 0xbb, 0x78, + 0x33, 0xcf, 0x2e, 0xa6, 0xc0, 0x7e, 0xc6, 0xe6, 0x14, 0x58, 0x5c, 0x5f, 0xbe, 0x4e, 0xa2, 0xfc, + 0x14, 0x70, 0x56, 0xb7, 0x33, 0x74, 0x2a, 0xd6, 0xbf, 0x54, 0x22, 0xc8, 0x27, 0x11, 0x4d, 0xff, + 0x16, 0x01, 0x6f, 0xc4, 0xc0, 0x71, 0x79, 0x49, 0x44, 0x49, 0x4a, 0x40, 0xea, 0xa2, 0x42, 0x87, + 0xce, 0xba, 0x08, 0xc7, 0x67, 0x65, 0x85, 0x93, 0xe7, 0x77, 0xca, 0x89, 0x7d, 0xaf, 0x01, 0xec, + 0x47, 0x5b, 0x49, 0xfa, 0x2f, 0x37, 0x5e, 0xf2, 0x80, 0x49, 0xe6, 0x32, 0x4b, 0x26, 0xc1, 0xd9, + 0x2e, 0xa8, 0xd5, 0xd2, 0x15, 0x61, 0x25, 0x27, 0x7a, 0xe7, 0xc4, 0xaa, 0xcf, 0xf8, 0x30, 0x3e, + 0x82, 0xb8, 0xf6, 0x23, 0x9e, 0x66, 0x75, 0xbc, 0xe1, 0xf8, 0x82, 0xd7, 0x2e, 0x02, 0xdc, 0xb9, + 0xad, 0xc1, 0x8c, 0xe5, 0x50, 0x65, 0x49, 0xf5, 0xdb, 0x91, 0xdc, 0x7b, 0x6e, 0xc6, 0xc3, 0xaa, + 0xfc, 0x0a, 0xb9, 0x34, 0xb4, 0x24, 0x95, 0x59, 0x21, 0x4f, 0x21, 0xc3, 0xba, 0xcb, 0xbf, 0x51, + 0x99, 0xcd, 0xa0, 0xe4, 0x75, 0xf4, 0x98, 0xe4, 0x15, 0x6a, 0xdb, 0x31, 0xd8, 0xb4, 0x80, 0xec, + 0x01, 0x07, 0x2d, 0x5b, 0xc3, 0x08, 0x63, 0x81, 0x93, 0xad, 0x7c, 0xcc, 0x46, 0xe1, 0x3f, 0xfd, + 0xc7, 0x71, 0x29, 0x17, 0xd4, 0x82, 0xe4, 0x27, 0x69, 0x77, 0x19, 0x36, 0x85, 0xea, 0x28, 0xa4, + 0x4b, 0xd5, 0x7b, 0x98, 0x7a, 0x38, 0xff, 0x8b, 0x09, 0x76, 0x3e, 0xfb, 0x72, 0x2e, 0x33, 0x49, + 0x9d, 0x75, 0xbd, 0x9b, 0x7e, 0x91, 0xa6, 0x88, 0x9d, 0x7c, 0x4a, 0xce, 0x18, 0xfe, 0x1e, 0x07, + 0x47, 0xb5, 0x2f, 0x43, 0xc5, 0xe3, 0x62, 0xd6, 0x76, 0xa2, 0x76, 0x17, 0x40, 0xde, 0xda, 0xca, + 0x7a, 0x8c, 0xd4, 0x1b, 0xf0, 0x11, 0xbf, 0xe6, 0x9a, 0xbe, 0x77, 0x00, 0x09, 0x1d, 0xc9, 0x83, + 0xa9, 0x96, 0x22, 0x34, 0x47, 0xfb, 0x61, 0x20, 0x19, 0x8e, 0xa9, 0x08, 0x2f, 0x7c, 0x04, 0xc4, + 0x37, 0xed, 0x3c, 0xfb, 0x29, 0x5f, 0xa0, 0x6f, 0x03, 0xcc, 0xcd, 0x04, 0xcc, 0x5a, 0x42, 0xe9, + 0x07, 0x80, 0xad, 0xa5, 0x98, 0x4e, 0xca, 0xdb, 0x24, 0x2d, 0x9f, 0x7a, 0x0e, 0x3d, 0xfe, 0x5d, + 0xd2, 0x32, 0x3e, 0x52, 0x34, 0xd3, 0x04, 0x25, 0x17, 0x77, 0x60, 0xbe, 0x95, 0xcc, 0xa9, 0xe4, + 0x23, 0x12, 0x39, 0x9f, 0x41, 0xcf, 0xbc, 0x0f, 0xb3, 0xf4, 0x74, 0xee, 0x79, 0x77, 0x43, 0x07, + 0xc5, 0x41, 0x10, 0xcf, 0xd9, 0x7c, 0x92, 0xbc, 0x4e, 0x3c, 0x37, 0x53, 0x46, 0x9c, 0x80, 0x52, + 0x14, 0x45, 0x3f, 0xce, 0x0e, 0x82, 0xfc, 0x65, 0x9a, 0x17, 0x94, 0xd9, 0xc1, 0x26, 0xa0, 0xad, + 0x17, 0x3c, 0xfd, 0xe1, 0x3b, 0x69, 0x5b, 0x39, 0x47, 0x9c, 0xbe, 0x62, 0x42, 0x85, 0x6c, 0xd6, + 0xa1, 0x4d, 0x46, 0x5a, 0x99, 0x28, 0xc9, 0x7e, 0xc2, 0xb3, 0x8c, 0x5f, 0x65, 0x28, 0xc6, 0xf9, + 0x7e, 0xfa, 0xf1, 0x3d, 0x17, 0x90, 0x80, 0x56, 0xd5, 0xcc, 0x7d, 0xa5, 0x11, 0x9b, 0x84, 0xfa, + 0x8e, 0xe4, 0x9f, 0x4a, 0x6c, 0x25, 0x6f, 0xab, 0x8f, 0x9a, 0x10, 0xfd, 0xf9, 0x27, 0x9e, 0x80, + 0xdc, 0xa8, 0xb7, 0xde, 0x8e, 0xc2, 0x5e, 0x6c, 0x44, 0xf5, 0x62, 0x92, 0x65, 0x42, 0xca, 0x3d, + 0xac, 0x25, 0x40, 0x56, 0xb0, 0xcf, 0x65, 0x41, 0x52, 0xa7, 0xb5, 0xcc, 0xa6, 0x5c, 0x4c, 0xbe, + 0x22, 0x9e, 0x81, 0x44, 0x21, 0xe6, 0xb1, 0x46, 0x34, 0x1f, 0x14, 0xa7, 0x24, 0xf4, 0x01, 0x4d, + 0xf5, 0x17, 0xec, 0xe6, 0x90, 0x92, 0x2b, 0xdf, 0x57, 0x61, 0x86, 0x5c, 0x2c, 0x65, 0x3c, 0xd2, + 0x9f, 0x26, 0xe1, 0x47, 0x08, 0xfe, 0x6f, 0x47, 0xd8, 0xb5, 0x13, 0xf0, 0x7f, 0xb7, 0x87, 0xf2, + 0x11, 0x63, 0xe4, 0xba, 0xed, 0x3e, 0xe3, 0x26, 0xeb, 0xa1, 0xed, 0xc1, 0x59, 0x92, 0xc4, 0x11, + 0x94, 0xe3, 0x58, 0x19, 0x6f, 0x3f, 0xaa, 0xb9, 0x70, 0x62, 0x6d, 0x14, 0xd7, 0xb3, 0x9c, 0x38, + 0x87, 0x71, 0x9d, 0xf9, 0x51, 0xf2, 0x02, 0xee, 0x84, 0x12, 0x72, 0xdd, 0x5d, 0xfd, 0xf7, 0x12, + 0x5b, 0x3a, 0xf9, 0x80, 0xd4, 0xd9, 0xaf, 0xb1, 0x49, 0x25, 0x8b, 0x22, 0x41, 0xee, 0x5a, 0xc3, + 0xce, 0xb5, 0x64, 0xf3, 0xe3, 0x60, 0xbf, 0x1f, 0xbd, 0x48, 0x27, 0x2a, 0x8f, 0xd9, 0x74, 0xbf, + 0x2f, 0xa5, 0x33, 0x25, 0xfd, 0x06, 0x50, 0x70, 0xe1, 0x23, 0xb9, 0x0b, 0x97, 0xfa, 0xf4, 0xcf, + 0x63, 0x6c, 0x39, 0x23, 0xd3, 0x36, 0x6f, 0x40, 0x11, 0xd4, 0x7c, 0x19, 0x60, 0xe1, 0xf6, 0xbc, + 0xcb, 0xbb, 0xfd, 0x60, 0x92, 0x09, 0x58, 0x35, 0x66, 0x50, 0xa2, 0x0f, 0xe3, 0xec, 0x3e, 0xb1, + 0x28, 0x4b, 0x72, 0xfa, 0x9a, 0x27, 0xcd, 0x7f, 0x21, 0xe7, 0xf0, 0x44, 0x8d, 0xd7, 0x9f, 0xd6, + 0x40, 0x96, 0x23, 0xfd, 0xe8, 0x28, 0xf9, 0xd1, 0x5f, 0xc2, 0xac, 0xdf, 0xdf, 0x94, 0xcf, 0x9d, + 0xc9, 0xec, 0xb3, 0xe9, 0x1c, 0x42, 0xfa, 0xe5, 0xfb, 0xf2, 0xbe, 0xd1, 0xab, 0x82, 0xfb, 0x72, + 0xda, 0xb1, 0x77, 0x96, 0x59, 0x5e, 0x43, 0x16, 0x24, 0xf8, 0xc8, 0x64, 0xcb, 0x16, 0x81, 0x05, + 0x28, 0xea, 0x18, 0xe5, 0x1d, 0x96, 0xf1, 0x57, 0x25, 0x76, 0x3a, 0x3d, 0x46, 0x06, 0x52, 0x95, + 0x4a, 0x1d, 0xc1, 0xf2, 0x22, 0xce, 0x91, 0x01, 0xb8, 0xad, 0x84, 0xa0, 0x12, 0x31, 0x2f, 0x44, + 0xbf, 0x52, 0x31, 0xd1, 0x65, 0xd1, 0x22, 0x6a, 0x5e, 0x62, 0x46, 0x64, 0xfa, 0x1c, 0xea, 0x6f, + 0xd0, 0x47, 0x9e, 0x92, 0x37, 0x55, 0x32, 0xcd, 0xea, 0x92, 0xd5, 0x56, 0x2f, 0xe7, 0x71, 0x58, + 0x59, 0x97, 0x1d, 0xb4, 0xdd, 0xdc, 0x91, 0xc4, 0x47, 0x20, 0x24, 0x28, 0x96, 0x4c, 0x86, 0x2b, + 0xb5, 0xd6, 0xfe, 0x9a, 0x2e, 0x8f, 0xf8, 0x65, 0xe2, 0x24, 0xe5, 0x27, 0x1c, 0x5a, 0xa7, 0xfb, + 0x06, 0x43, 0xf4, 0x92, 0xce, 0x41, 0x0f, 0xe9, 0xde, 0x4d, 0x9a, 0x0b, 0xdb, 0x7a, 0xe2, 0xf4, + 0xb0, 0x94, 0xaa, 0xfb, 0xa0, 0x61, 0x30, 0x69, 0x4f, 0x7a, 0x5c, 0x48, 0x6b, 0x0e, 0x79, 0x58, + 0x5d, 0x61, 0xd7, 0x87, 0x51, 0x1e, 0xe5, 0x76, 0xff, 0xc3, 0xc8, 0x7d, 0x9e, 0xf1, 0x1c, 0x0b, + 0x89, 0x34, 0x4d, 0xf4, 0x98, 0x31, 0x2a, 0x2f, 0xa4, 0x32, 0xc9, 0xac, 0x85, 0x28, 0x0b, 0xde, + 0xc6, 0x67, 0x5e, 0xf9, 0x49, 0x43, 0x5a, 0xb1, 0x08, 0x85, 0x58, 0x11, 0xd8, 0x83, 0xfc, 0xb0, + 0x10, 0x07, 0x0b, 0xab, 0x69, 0x5c, 0x50, 0x04, 0x8f, 0x54, 0xca, 0x79, 0xc0, 0x39, 0xf5, 0xa8, + 0x1b, 0x86, 0x58, 0xe2, 0x63, 0x7b, 0x86, 0xc4, 0x19, 0xfd, 0x01, 0x48, 0x9c, 0x7b, 0x85, 0x2f, + 0xd8, 0xb5, 0x0b, 0x80, 0x58, 0x79, 0xa8, 0x4b, 0x6a, 0xf5, 0x22, 0xdb, 0x2f, 0xa8, 0x0d, 0x4b, + 0x9b, 0x96, 0x4c, 0x48, 0x28, 0x43, 0xee, 0x0f, 0x97, 0x6f, 0xdc, 0x22, 0x31, 0xfe, 0x69, 0x86, + 0x4e, 0x91, 0x79, 0x08, 0x1d, 0xd4, 0x6e, 0x96, 0x33, 0x80, 0x74, 0x84, 0x67, 0x4d, 0xa3, 0xe3, + 0x84, 0x90, 0x06, 0x10, 0x5b, 0x03, 0x29, 0xdf, 0x51, 0x8e, 0x34, 0x99, 0xfc, 0x51, 0x49, 0x93, + 0xdf, 0xe6, 0xed, 0x70, 0x2a, 0x61, 0x87, 0x3e, 0x2c, 0xdb, 0x4c, 0xdb, 0xa1, 0xd4, 0xd1, 0x93, + 0xec, 0x10, 0x0a, 0x5b, 0x68, 0x0c, 0x8f, 0x3c, 0x41, 0x65, 0x45, 0x6f, 0x08, 0x33, 0xc4, 0x2c, + 0xea, 0x74, 0xcc, 0xe0, 0xc8, 0xf7, 0xee, 0x69, 0xda, 0x3c, 0x29, 0x41, 0xcc, 0xc9, 0x50, 0x4f, + 0x9a, 0x9a, 0x42, 0xdf, 0x82, 0x7b, 0x6e, 0xf7, 0xfa, 0x54, 0x03, 0xc9, 0x89, 0x1f, 0x61, 0x06, + 0x2d, 0x2f, 0x8a, 0x62, 0x44, 0xc9, 0x76, 0xd1, 0x47, 0x98, 0x1b, 0x19, 0x20, 0x7c, 0xad, 0x3b, + 0x16, 0x6c, 0x93, 0xcd, 0x08, 0xee, 0x84, 0x70, 0x58, 0x48, 0x38, 0xc8, 0xaf, 0x0e, 0x24, 0xd4, + 0xae, 0x22, 0x20, 0xe4, 0x4d, 0x2b, 0x03, 0xc6, 0x49, 0xd7, 0x84, 0x7a, 0xd5, 0x02, 0x37, 0x99, + 0xac, 0xf2, 0x1e, 0x24, 0xc8, 0xa3, 0x53, 0xaf, 0xe4, 0xa7, 0xb7, 0xd8, 0x22, 0xd5, 0xac, 0x76, + 0x36, 0xe6, 0xcf, 0x52, 0xcc, 0xa7, 0x3c, 0x7c, 0x03, 0x62, 0x2c, 0x5d, 0x8c, 0xbc, 0x2c, 0xda, + 0x62, 0xc8, 0x1b, 0x1c, 0xcc, 0xad, 0x2e, 0xcb, 0xbc, 0x7d, 0xef, 0x50, 0xdd, 0xa5, 0x65, 0xfc, + 0xa6, 0xc4, 0xc6, 0x5c, 0xa7, 0x27, 0x14, 0x8b, 0x15, 0x01, 0x42, 0x07, 0xee, 0xbc, 0x6f, 0xfc, + 0xe8, 0xbe, 0x0f, 0xec, 0x62, 0x4b, 0xb7, 0xb7, 0x9d, 0xf6, 0x01, 0x77, 0x6b, 0xbd, 0x5d, 0x00, + 0x77, 0x95, 0x8e, 0x24, 0x3f, 0x3b, 0xeb, 0x5b, 0x2b, 0xae, 0xa1, 0xd3, 0x0c, 0x7a, 0x99, 0xa2, + 0xdc, 0xf7, 0xcb, 0xdb, 0x2b, 0xf7, 0x7f, 0x61, 0x19, 0xff, 0x50, 0x8a, 0x3f, 0xb4, 0xb2, 0x43, + 0x8e, 0x2f, 0x38, 0xb6, 0x7c, 0xbd, 0xa2, 0x7c, 0x63, 0x8e, 0xf2, 0x8d, 0x3f, 0x2d, 0x81, 0x68, + 0x7f, 0x5c, 0xfa, 0x7e, 0xb2, 0xf9, 0x1e, 0xe8, 0x83, 0xf2, 0x1c, 0x74, 0xd7, 0x5f, 0xe1, 0xdd, + 0x83, 0x58, 0x89, 0xb3, 0x22, 0x3d, 0x95, 0x22, 0xe2, 0x5b, 0xa8, 0xba, 0x4f, 0x90, 0xdf, 0x0c, + 0x29, 0x33, 0xa2, 0xd3, 0x1b, 0xcc, 0x89, 0x5d, 0xfc, 0xe1, 0x39, 0xb1, 0x5f, 0x25, 0x12, 0x86, + 0x4b, 0x3a, 0x33, 0xfa, 0x0c, 0xe0, 0x3f, 0x7e, 0xac, 0x1f, 0x51, 0xd1, 0xc0, 0x49, 0x3b, 0x51, + 0xff, 0x1c, 0x52, 0x00, 0x11, 0x98, 0x47, 0xf4, 0xb9, 0x1f, 0x8f, 0x44, 0x9f, 0x99, 0x2e, 0xa6, + 0xc7, 0xfc, 0x02, 0xfa, 0xb4, 0x4a, 0xc9, 0xd2, 0x92, 0x75, 0x62, 0xb0, 0x78, 0x65, 0xf2, 0x34, + 0x45, 0xc6, 0xcd, 0xff, 0xa8, 0x64, 0x9c, 0x55, 0x40, 0x8e, 0x49, 0xfa, 0x6f, 0x28, 0x5a, 0xcc, + 0x18, 0x9e, 0x16, 0x5b, 0xcf, 0xd1, 0x62, 0xaf, 0xe5, 0x48, 0x9b, 0xef, 0x46, 0x88, 0x2d, 0xfc, + 0x58, 0x84, 0xd8, 0xe2, 0x77, 0x21, 0xc4, 0x1a, 0xc7, 0x10, 0x62, 0x92, 0xba, 0xfb, 0x71, 0xa9, + 0xb0, 0x0b, 0xdf, 0x85, 0x0a, 0x7b, 0x37, 0x4f, 0x85, 0x99, 0x49, 0x2a, 0xec, 0x2c, 0xc0, 0x2d, + 0x16, 0x52, 0x61, 0xc3, 0x91, 0x60, 0xbf, 0x1d, 0xc9, 0x3d, 0xa0, 0xa6, 0xec, 0x44, 0x95, 0x22, + 0xbb, 0x29, 0x0a, 0xac, 0xb6, 0x0e, 0xab, 0x3e, 0x7c, 0x1a, 0xab, 0xb2, 0xe4, 0xf1, 0xd1, 0x31, + 0x76, 0xd1, 0x61, 0xd1, 0xf7, 0x23, 0xe0, 0x0c, 0x85, 0x70, 0x42, 0x0f, 0x8c, 0x20, 0x9b, 0x29, + 0x6a, 0x93, 0x36, 0xfe, 0xac, 0x34, 0x80, 0x36, 0x1b, 0x39, 0x86, 0x36, 0xab, 0x7d, 0x0e, 0x8b, + 0xef, 0xae, 0x3b, 0xea, 0x59, 0x22, 0x56, 0x9d, 0x23, 0x0f, 0x22, 0x07, 0x66, 0x13, 0xea, 0x30, + 0x40, 0x10, 0x97, 0x77, 0xe4, 0x13, 0x38, 0x46, 0xc6, 0x23, 0x19, 0x4e, 0xa4, 0xd9, 0xd0, 0x8b, + 0x94, 0x7c, 0xd1, 0xeb, 0x3f, 0x0b, 0xde, 0xf9, 0xfb, 0xd3, 0x6c, 0x36, 0xb5, 0x24, 0x7e, 0xa2, + 0x3e, 0x1d, 0xff, 0xc2, 0xc3, 0xb8, 0x64, 0x9d, 0xf4, 0xcb, 0x9b, 0x4a, 0xd5, 0x3a, 0xf9, 0x67, + 0x32, 0xa4, 0x02, 0x71, 0xbb, 0xe8, 0xbf, 0x5b, 0x16, 0x7e, 0xf0, 0x6d, 0xfc, 0x49, 0x89, 0xcd, + 0x24, 0x7e, 0xcf, 0x62, 0x5c, 0xb6, 0x4e, 0xfe, 0x91, 0x4d, 0xe5, 0x8a, 0x35, 0xcc, 0x2f, 0x62, + 0x28, 0xec, 0x26, 0x7a, 0x12, 0xb2, 0x34, 0xc2, 0xa0, 0x55, 0x24, 0xcd, 0x5f, 0x97, 0xd8, 0xa9, + 0xe4, 0xcf, 0x5e, 0x8c, 0xdc, 0x4a, 0x45, 0x3f, 0xaa, 0xa9, 0x5c, 0xb5, 0x86, 0xf9, 0xe9, 0x4c, + 0x95, 0x72, 0xa6, 0x47, 0x4d, 0x5e, 0x3f, 0x40, 0x3b, 0x88, 0x85, 0x21, 0xc6, 0x46, 0x8f, 0x1e, + 0x70, 0x4c, 0xdf, 0x96, 0xd8, 0xa4, 0x5a, 0xc2, 0xb8, 0x68, 0x1d, 0xff, 0x43, 0x9b, 0x8a, 0x69, + 0x9d, 0xf0, 0xed, 0x78, 0x95, 0x6a, 0x27, 0x3d, 0x06, 0x3f, 0x4d, 0xa7, 0x87, 0x26, 0x58, 0x4c, + 0x9e, 0x8e, 0xca, 0x4d, 0x51, 0x0e, 0xfd, 0x2e, 0x6e, 0x19, 0x7f, 0x5e, 0x62, 0xac, 0xff, 0x69, + 0x83, 0x51, 0xb5, 0x4e, 0xfc, 0x9a, 0xbc, 0x72, 0xd9, 0x3a, 0xf9, 0xd3, 0x88, 0xaa, 0xca, 0x24, + 0xe5, 0xb7, 0xe3, 0x22, 0xf5, 0x71, 0xb6, 0xb3, 0x17, 0x74, 0x23, 0xfc, 0xce, 0xb8, 0xe8, 0xb3, + 0x73, 0x88, 0xc0, 0x7f, 0x09, 0xca, 0x93, 0x78, 0xe1, 0x37, 0x2e, 0x0f, 0xf1, 0x19, 0x43, 0x5e, + 0x79, 0x8a, 0xbe, 0x11, 0xf8, 0x3e, 0x52, 0xfd, 0x21, 0x28, 0x51, 0x92, 0xde, 0x36, 0xae, 0x0c, + 0xf3, 0xd6, 0x99, 0x57, 0xa2, 0x42, 0x8a, 0xbc, 0xaa, 0xe2, 0xb9, 0x16, 0x4c, 0x06, 0xda, 0xbe, + 0x0c, 0x50, 0x83, 0x3a, 0x74, 0x8b, 0x96, 0xf1, 0x6b, 0x36, 0x21, 0xc9, 0x3d, 0xe3, 0x82, 0x75, + 0x2c, 0x0f, 0x5e, 0xb9, 0x68, 0x9d, 0x40, 0x0a, 0x12, 0xf9, 0x2a, 0x1b, 0x8b, 0xcf, 0x22, 0xcb, + 0x94, 0xfe, 0x4b, 0x89, 0x2d, 0x16, 0x92, 0x6f, 0xc6, 0x4d, 0xeb, 0x55, 0xd8, 0xc5, 0x8a, 0x65, + 0xbd, 0x12, 0xa5, 0x57, 0xa5, 0xf4, 0x4e, 0x46, 0x20, 0x21, 0x53, 0x3b, 0x2a, 0xbc, 0x54, 0x22, + 0x57, 0xcf, 0xf2, 0x68, 0x1c, 0x67, 0x53, 0xba, 0x97, 0xdd, 0x83, 0xf1, 0x77, 0x25, 0x36, 0x9f, + 0x5d, 0xcc, 0x58, 0xb2, 0x86, 0x64, 0x00, 0x2b, 0xcb, 0x43, 0xd3, 0x59, 0x55, 0xfa, 0x0d, 0x40, + 0x56, 0xe6, 0x62, 0xd2, 0x2f, 0x2f, 0xe6, 0xdf, 0x94, 0x98, 0x91, 0x27, 0x16, 0x8c, 0xdc, 0xfb, + 0xfa, 0x60, 0xe6, 0xaa, 0x72, 0xc3, 0x7a, 0x05, 0xa2, 0x82, 0x3e, 0x02, 0x51, 0x03, 0x72, 0x9c, + 0x48, 0x9c, 0x38, 0xa3, 0x06, 0x1a, 0x7f, 0x04, 0x1e, 0xa3, 0x1f, 0x6f, 0xf3, 0x1e, 0x23, 0x9f, + 0xb3, 0xe6, 0x3d, 0x46, 0x41, 0xbc, 0x96, 0xda, 0xb8, 0xc5, 0x43, 0x54, 0x43, 0x41, 0x86, 0x48, + 0x29, 0x36, 0xe5, 0x96, 0x24, 0x41, 0xc6, 0x24, 0x2b, 0xf2, 0x37, 0x82, 0x44, 0xcc, 0x78, 0x75, + 0x72, 0x6d, 0xf8, 0x2d, 0xb6, 0xc8, 0x3d, 0xf0, 0xe0, 0xd9, 0xd7, 0x46, 0xbf, 0x2d, 0x95, 0xfe, + 0x3f, 0x00, 0x00, 0xff, 0xff, 0x6e, 0x8f, 0x7b, 0xab, 0xe5, 0x3a, 0x00, 0x00, +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/enums.go b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/enums.go new file mode 100644 index 00000000..e9599346 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/enums.go @@ -0,0 +1,6539 @@ +// Generated code +// DO NOT EDIT + +package steamlang + +import ( + "fmt" + "sort" + "strings" +) + +type EMsg int32 + +const ( + EMsg_Invalid EMsg = 0 + EMsg_Multi EMsg = 1 + EMsg_BaseGeneral EMsg = 100 + EMsg_GenericReply EMsg = 100 + EMsg_DestJobFailed EMsg = 113 + EMsg_Alert EMsg = 115 + EMsg_SCIDRequest EMsg = 120 + EMsg_SCIDResponse EMsg = 121 + EMsg_JobHeartbeat EMsg = 123 + EMsg_HubConnect EMsg = 124 + EMsg_Subscribe EMsg = 126 + EMsg_RouteMessage EMsg = 127 + EMsg_RemoteSysID EMsg = 128 + EMsg_AMCreateAccountResponse EMsg = 129 + EMsg_WGRequest EMsg = 130 + EMsg_WGResponse EMsg = 131 + EMsg_KeepAlive EMsg = 132 + EMsg_WebAPIJobRequest EMsg = 133 + EMsg_WebAPIJobResponse EMsg = 134 + EMsg_ClientSessionStart EMsg = 135 + EMsg_ClientSessionEnd EMsg = 136 + EMsg_ClientSessionUpdateAuthTicket EMsg = 137 + EMsg_StatsDeprecated EMsg = 138 // Deprecated + EMsg_Ping EMsg = 139 + EMsg_PingResponse EMsg = 140 + EMsg_Stats EMsg = 141 + EMsg_RequestFullStatsBlock EMsg = 142 + EMsg_LoadDBOCacheItem EMsg = 143 + EMsg_LoadDBOCacheItemResponse EMsg = 144 + EMsg_InvalidateDBOCacheItems EMsg = 145 + EMsg_ServiceMethod EMsg = 146 + EMsg_ServiceMethodResponse EMsg = 147 + EMsg_BaseShell EMsg = 200 + EMsg_AssignSysID EMsg = 200 + EMsg_Exit EMsg = 201 + EMsg_DirRequest EMsg = 202 + EMsg_DirResponse EMsg = 203 + EMsg_ZipRequest EMsg = 204 + EMsg_ZipResponse EMsg = 205 + EMsg_UpdateRecordResponse EMsg = 215 + EMsg_UpdateCreditCardRequest EMsg = 221 + EMsg_UpdateUserBanResponse EMsg = 225 + EMsg_PrepareToExit EMsg = 226 + EMsg_ContentDescriptionUpdate EMsg = 227 + EMsg_TestResetServer EMsg = 228 + EMsg_UniverseChanged EMsg = 229 + EMsg_ShellConfigInfoUpdate EMsg = 230 + EMsg_RequestWindowsEventLogEntries EMsg = 233 + EMsg_ProvideWindowsEventLogEntries EMsg = 234 + EMsg_ShellSearchLogs EMsg = 235 + EMsg_ShellSearchLogsResponse EMsg = 236 + EMsg_ShellCheckWindowsUpdates EMsg = 237 + EMsg_ShellCheckWindowsUpdatesResponse EMsg = 238 + EMsg_ShellFlushUserLicenseCache EMsg = 239 + EMsg_BaseGM EMsg = 300 + EMsg_Heartbeat EMsg = 300 + EMsg_ShellFailed EMsg = 301 + EMsg_ExitShells EMsg = 307 + EMsg_ExitShell EMsg = 308 + EMsg_GracefulExitShell EMsg = 309 + EMsg_NotifyWatchdog EMsg = 314 + EMsg_LicenseProcessingComplete EMsg = 316 + EMsg_SetTestFlag EMsg = 317 + EMsg_QueuedEmailsComplete EMsg = 318 + EMsg_GMReportPHPError EMsg = 319 + EMsg_GMDRMSync EMsg = 320 + EMsg_PhysicalBoxInventory EMsg = 321 + EMsg_UpdateConfigFile EMsg = 322 + EMsg_TestInitDB EMsg = 323 + EMsg_GMWriteConfigToSQL EMsg = 324 + EMsg_GMLoadActivationCodes EMsg = 325 + EMsg_GMQueueForFBS EMsg = 326 + EMsg_GMSchemaConversionResults EMsg = 327 + EMsg_GMSchemaConversionResultsResponse EMsg = 328 + EMsg_GMWriteShellFailureToSQL EMsg = 329 + EMsg_BaseAIS EMsg = 400 + EMsg_AISRefreshContentDescription EMsg = 401 + EMsg_AISRequestContentDescription EMsg = 402 + EMsg_AISUpdateAppInfo EMsg = 403 + EMsg_AISUpdatePackageInfo EMsg = 404 + EMsg_AISGetPackageChangeNumber EMsg = 405 + EMsg_AISGetPackageChangeNumberResponse EMsg = 406 + EMsg_AISAppInfoTableChanged EMsg = 407 + EMsg_AISUpdatePackageInfoResponse EMsg = 408 + EMsg_AISCreateMarketingMessage EMsg = 409 + EMsg_AISCreateMarketingMessageResponse EMsg = 410 + EMsg_AISGetMarketingMessage EMsg = 411 + EMsg_AISGetMarketingMessageResponse EMsg = 412 + EMsg_AISUpdateMarketingMessage EMsg = 413 + EMsg_AISUpdateMarketingMessageResponse EMsg = 414 + EMsg_AISRequestMarketingMessageUpdate EMsg = 415 + EMsg_AISDeleteMarketingMessage EMsg = 416 + EMsg_AISGetMarketingTreatments EMsg = 419 + EMsg_AISGetMarketingTreatmentsResponse EMsg = 420 + EMsg_AISRequestMarketingTreatmentUpdate EMsg = 421 + EMsg_AISTestAddPackage EMsg = 422 + EMsg_AIGetAppGCFlags EMsg = 423 + EMsg_AIGetAppGCFlagsResponse EMsg = 424 + EMsg_AIGetAppList EMsg = 425 + EMsg_AIGetAppListResponse EMsg = 426 + EMsg_AIGetAppInfo EMsg = 427 + EMsg_AIGetAppInfoResponse EMsg = 428 + EMsg_AISGetCouponDefinition EMsg = 429 + EMsg_AISGetCouponDefinitionResponse EMsg = 430 + EMsg_BaseAM EMsg = 500 + EMsg_AMUpdateUserBanRequest EMsg = 504 + EMsg_AMAddLicense EMsg = 505 + EMsg_AMBeginProcessingLicenses EMsg = 507 + EMsg_AMSendSystemIMToUser EMsg = 508 + EMsg_AMExtendLicense EMsg = 509 + EMsg_AMAddMinutesToLicense EMsg = 510 + EMsg_AMCancelLicense EMsg = 511 + EMsg_AMInitPurchase EMsg = 512 + EMsg_AMPurchaseResponse EMsg = 513 + EMsg_AMGetFinalPrice EMsg = 514 + EMsg_AMGetFinalPriceResponse EMsg = 515 + EMsg_AMGetLegacyGameKey EMsg = 516 + EMsg_AMGetLegacyGameKeyResponse EMsg = 517 + EMsg_AMFindHungTransactions EMsg = 518 + EMsg_AMSetAccountTrustedRequest EMsg = 519 + EMsg_AMCompletePurchase EMsg = 521 + EMsg_AMCancelPurchase EMsg = 522 + EMsg_AMNewChallenge EMsg = 523 + EMsg_AMFixPendingPurchaseResponse EMsg = 526 + EMsg_AMIsUserBanned EMsg = 527 + EMsg_AMRegisterKey EMsg = 528 + EMsg_AMLoadActivationCodes EMsg = 529 + EMsg_AMLoadActivationCodesResponse EMsg = 530 + EMsg_AMLookupKeyResponse EMsg = 531 + EMsg_AMLookupKey EMsg = 532 + EMsg_AMChatCleanup EMsg = 533 + EMsg_AMClanCleanup EMsg = 534 + EMsg_AMFixPendingRefund EMsg = 535 + EMsg_AMReverseChargeback EMsg = 536 + EMsg_AMReverseChargebackResponse EMsg = 537 + EMsg_AMClanCleanupList EMsg = 538 + EMsg_AMGetLicenses EMsg = 539 + EMsg_AMGetLicensesResponse EMsg = 540 + EMsg_AllowUserToPlayQuery EMsg = 550 + EMsg_AllowUserToPlayResponse EMsg = 551 + EMsg_AMVerfiyUser EMsg = 552 + EMsg_AMClientNotPlaying EMsg = 553 + EMsg_ClientRequestFriendship EMsg = 554 + EMsg_AMRelayPublishStatus EMsg = 555 + EMsg_AMResetCommunityContent EMsg = 556 + EMsg_AMPrimePersonaStateCache EMsg = 557 + EMsg_AMAllowUserContentQuery EMsg = 558 + EMsg_AMAllowUserContentResponse EMsg = 559 + EMsg_AMInitPurchaseResponse EMsg = 560 + EMsg_AMRevokePurchaseResponse EMsg = 561 + EMsg_AMLockProfile EMsg = 562 + EMsg_AMRefreshGuestPasses EMsg = 563 + EMsg_AMInviteUserToClan EMsg = 564 + EMsg_AMAcknowledgeClanInvite EMsg = 565 + EMsg_AMGrantGuestPasses EMsg = 566 + EMsg_AMClanDataUpdated EMsg = 567 + EMsg_AMReloadAccount EMsg = 568 + EMsg_AMClientChatMsgRelay EMsg = 569 + EMsg_AMChatMulti EMsg = 570 + EMsg_AMClientChatInviteRelay EMsg = 571 + EMsg_AMChatInvite EMsg = 572 + EMsg_AMClientJoinChatRelay EMsg = 573 + EMsg_AMClientChatMemberInfoRelay EMsg = 574 + EMsg_AMPublishChatMemberInfo EMsg = 575 + EMsg_AMClientAcceptFriendInvite EMsg = 576 + EMsg_AMChatEnter EMsg = 577 + EMsg_AMClientPublishRemovalFromSource EMsg = 578 + EMsg_AMChatActionResult EMsg = 579 + EMsg_AMFindAccounts EMsg = 580 + EMsg_AMFindAccountsResponse EMsg = 581 + EMsg_AMSetAccountFlags EMsg = 584 + EMsg_AMCreateClan EMsg = 586 + EMsg_AMCreateClanResponse EMsg = 587 + EMsg_AMGetClanDetails EMsg = 588 + EMsg_AMGetClanDetailsResponse EMsg = 589 + EMsg_AMSetPersonaName EMsg = 590 + EMsg_AMSetAvatar EMsg = 591 + EMsg_AMAuthenticateUser EMsg = 592 + EMsg_AMAuthenticateUserResponse EMsg = 593 + EMsg_AMGetAccountFriendsCount EMsg = 594 + EMsg_AMGetAccountFriendsCountResponse EMsg = 595 + EMsg_AMP2PIntroducerMessage EMsg = 596 + EMsg_ClientChatAction EMsg = 597 + EMsg_AMClientChatActionRelay EMsg = 598 + EMsg_BaseVS EMsg = 600 + EMsg_ReqChallenge EMsg = 600 + EMsg_VACResponse EMsg = 601 + EMsg_ReqChallengeTest EMsg = 602 + EMsg_VSMarkCheat EMsg = 604 + EMsg_VSAddCheat EMsg = 605 + EMsg_VSPurgeCodeModDB EMsg = 606 + EMsg_VSGetChallengeResults EMsg = 607 + EMsg_VSChallengeResultText EMsg = 608 + EMsg_VSReportLingerer EMsg = 609 + EMsg_VSRequestManagedChallenge EMsg = 610 + EMsg_VSLoadDBFinished EMsg = 611 + EMsg_BaseDRMS EMsg = 625 + EMsg_DRMBuildBlobRequest EMsg = 628 + EMsg_DRMBuildBlobResponse EMsg = 629 + EMsg_DRMResolveGuidRequest EMsg = 630 + EMsg_DRMResolveGuidResponse EMsg = 631 + EMsg_DRMVariabilityReport EMsg = 633 + EMsg_DRMVariabilityReportResponse EMsg = 634 + EMsg_DRMStabilityReport EMsg = 635 + EMsg_DRMStabilityReportResponse EMsg = 636 + EMsg_DRMDetailsReportRequest EMsg = 637 + EMsg_DRMDetailsReportResponse EMsg = 638 + EMsg_DRMProcessFile EMsg = 639 + EMsg_DRMAdminUpdate EMsg = 640 + EMsg_DRMAdminUpdateResponse EMsg = 641 + EMsg_DRMSync EMsg = 642 + EMsg_DRMSyncResponse EMsg = 643 + EMsg_DRMProcessFileResponse EMsg = 644 + EMsg_DRMEmptyGuidCache EMsg = 645 + EMsg_DRMEmptyGuidCacheResponse EMsg = 646 + EMsg_BaseCS EMsg = 650 + EMsg_CSUserContentRequest EMsg = 652 // Deprecated + EMsg_BaseClient EMsg = 700 + EMsg_ClientLogOn_Deprecated EMsg = 701 // Deprecated + EMsg_ClientAnonLogOn_Deprecated EMsg = 702 // Deprecated + EMsg_ClientHeartBeat EMsg = 703 + EMsg_ClientVACResponse EMsg = 704 + EMsg_ClientGamesPlayed_obsolete EMsg = 705 // Deprecated + EMsg_ClientLogOff EMsg = 706 + EMsg_ClientNoUDPConnectivity EMsg = 707 + EMsg_ClientInformOfCreateAccount EMsg = 708 + EMsg_ClientAckVACBan EMsg = 709 + EMsg_ClientConnectionStats EMsg = 710 + EMsg_ClientInitPurchase EMsg = 711 + EMsg_ClientPingResponse EMsg = 712 + EMsg_ClientRemoveFriend EMsg = 714 + EMsg_ClientGamesPlayedNoDataBlob EMsg = 715 + EMsg_ClientChangeStatus EMsg = 716 + EMsg_ClientVacStatusResponse EMsg = 717 + EMsg_ClientFriendMsg EMsg = 718 + EMsg_ClientGameConnect_obsolete EMsg = 719 // Deprecated + EMsg_ClientGamesPlayed2_obsolete EMsg = 720 // Deprecated + EMsg_ClientGameEnded_obsolete EMsg = 721 // Deprecated + EMsg_ClientGetFinalPrice EMsg = 722 + EMsg_ClientSystemIM EMsg = 726 + EMsg_ClientSystemIMAck EMsg = 727 + EMsg_ClientGetLicenses EMsg = 728 + EMsg_ClientCancelLicense EMsg = 729 // Deprecated + EMsg_ClientGetLegacyGameKey EMsg = 730 + EMsg_ClientContentServerLogOn_Deprecated EMsg = 731 // Deprecated + EMsg_ClientAckVACBan2 EMsg = 732 + EMsg_ClientAckMessageByGID EMsg = 735 // Deprecated + EMsg_ClientGetPurchaseReceipts EMsg = 736 + EMsg_ClientAckPurchaseReceipt EMsg = 737 + EMsg_ClientGamesPlayed3_obsolete EMsg = 738 // Deprecated + EMsg_ClientSendGuestPass EMsg = 739 + EMsg_ClientAckGuestPass EMsg = 740 + EMsg_ClientRedeemGuestPass EMsg = 741 + EMsg_ClientGamesPlayed EMsg = 742 + EMsg_ClientRegisterKey EMsg = 743 + EMsg_ClientInviteUserToClan EMsg = 744 + EMsg_ClientAcknowledgeClanInvite EMsg = 745 + EMsg_ClientPurchaseWithMachineID EMsg = 746 + EMsg_ClientAppUsageEvent EMsg = 747 + EMsg_ClientGetGiftTargetList EMsg = 748 // Deprecated + EMsg_ClientGetGiftTargetListResponse EMsg = 749 // Deprecated + EMsg_ClientLogOnResponse EMsg = 751 + EMsg_ClientVACChallenge EMsg = 753 + EMsg_ClientSetHeartbeatRate EMsg = 755 + EMsg_ClientNotLoggedOnDeprecated EMsg = 756 // Deprecated + EMsg_ClientLoggedOff EMsg = 757 + EMsg_GSApprove EMsg = 758 + EMsg_GSDeny EMsg = 759 + EMsg_GSKick EMsg = 760 + EMsg_ClientCreateAcctResponse EMsg = 761 + EMsg_ClientPurchaseResponse EMsg = 763 + EMsg_ClientPing EMsg = 764 + EMsg_ClientNOP EMsg = 765 + EMsg_ClientPersonaState EMsg = 766 + EMsg_ClientFriendsList EMsg = 767 + EMsg_ClientAccountInfo EMsg = 768 + EMsg_ClientVacStatusQuery EMsg = 770 + EMsg_ClientNewsUpdate EMsg = 771 + EMsg_ClientGameConnectDeny EMsg = 773 + EMsg_GSStatusReply EMsg = 774 + EMsg_ClientGetFinalPriceResponse EMsg = 775 + EMsg_ClientGameConnectTokens EMsg = 779 + EMsg_ClientLicenseList EMsg = 780 + EMsg_ClientCancelLicenseResponse EMsg = 781 // Deprecated + EMsg_ClientVACBanStatus EMsg = 782 + EMsg_ClientCMList EMsg = 783 + EMsg_ClientEncryptPct EMsg = 784 + EMsg_ClientGetLegacyGameKeyResponse EMsg = 785 + EMsg_ClientFavoritesList EMsg = 786 + EMsg_CSUserContentApprove EMsg = 787 // Deprecated + EMsg_CSUserContentDeny EMsg = 788 // Deprecated + EMsg_ClientInitPurchaseResponse EMsg = 789 + EMsg_ClientAddFriend EMsg = 791 + EMsg_ClientAddFriendResponse EMsg = 792 + EMsg_ClientInviteFriend EMsg = 793 // Deprecated + EMsg_ClientInviteFriendResponse EMsg = 794 // Deprecated + EMsg_ClientSendGuestPassResponse EMsg = 795 // Deprecated + EMsg_ClientAckGuestPassResponse EMsg = 796 + EMsg_ClientRedeemGuestPassResponse EMsg = 797 + EMsg_ClientUpdateGuestPassesList EMsg = 798 + EMsg_ClientChatMsg EMsg = 799 + EMsg_ClientChatInvite EMsg = 800 + EMsg_ClientJoinChat EMsg = 801 + EMsg_ClientChatMemberInfo EMsg = 802 + EMsg_ClientLogOnWithCredentials_Deprecated EMsg = 803 // Deprecated + EMsg_ClientPasswordChangeResponse EMsg = 805 + EMsg_ClientChatEnter EMsg = 807 + EMsg_ClientFriendRemovedFromSource EMsg = 808 + EMsg_ClientCreateChat EMsg = 809 + EMsg_ClientCreateChatResponse EMsg = 810 + EMsg_ClientUpdateChatMetadata EMsg = 811 + EMsg_ClientP2PIntroducerMessage EMsg = 813 + EMsg_ClientChatActionResult EMsg = 814 + EMsg_ClientRequestFriendData EMsg = 815 + EMsg_ClientGetUserStats EMsg = 818 + EMsg_ClientGetUserStatsResponse EMsg = 819 + EMsg_ClientStoreUserStats EMsg = 820 + EMsg_ClientStoreUserStatsResponse EMsg = 821 + EMsg_ClientClanState EMsg = 822 + EMsg_ClientServiceModule EMsg = 830 + EMsg_ClientServiceCall EMsg = 831 + EMsg_ClientServiceCallResponse EMsg = 832 + EMsg_ClientPackageInfoRequest EMsg = 833 + EMsg_ClientPackageInfoResponse EMsg = 834 + EMsg_ClientNatTraversalStatEvent EMsg = 839 + EMsg_ClientAppInfoRequest EMsg = 840 + EMsg_ClientAppInfoResponse EMsg = 841 + EMsg_ClientSteamUsageEvent EMsg = 842 + EMsg_ClientCheckPassword EMsg = 845 + EMsg_ClientResetPassword EMsg = 846 + EMsg_ClientCheckPasswordResponse EMsg = 848 + EMsg_ClientResetPasswordResponse EMsg = 849 + EMsg_ClientSessionToken EMsg = 850 + EMsg_ClientDRMProblemReport EMsg = 851 + EMsg_ClientSetIgnoreFriend EMsg = 855 + EMsg_ClientSetIgnoreFriendResponse EMsg = 856 + EMsg_ClientGetAppOwnershipTicket EMsg = 857 + EMsg_ClientGetAppOwnershipTicketResponse EMsg = 858 + EMsg_ClientGetLobbyListResponse EMsg = 860 + EMsg_ClientGetLobbyMetadata EMsg = 861 + EMsg_ClientGetLobbyMetadataResponse EMsg = 862 + EMsg_ClientVTTCert EMsg = 863 + EMsg_ClientAppInfoUpdate EMsg = 866 + EMsg_ClientAppInfoChanges EMsg = 867 + EMsg_ClientServerList EMsg = 880 + EMsg_ClientEmailChangeResponse EMsg = 891 + EMsg_ClientSecretQAChangeResponse EMsg = 892 + EMsg_ClientDRMBlobRequest EMsg = 896 + EMsg_ClientDRMBlobResponse EMsg = 897 + EMsg_ClientLookupKey EMsg = 898 + EMsg_ClientLookupKeyResponse EMsg = 899 + EMsg_BaseGameServer EMsg = 900 + EMsg_GSDisconnectNotice EMsg = 901 + EMsg_GSStatus EMsg = 903 + EMsg_GSUserPlaying EMsg = 905 + EMsg_GSStatus2 EMsg = 906 + EMsg_GSStatusUpdate_Unused EMsg = 907 + EMsg_GSServerType EMsg = 908 + EMsg_GSPlayerList EMsg = 909 + EMsg_GSGetUserAchievementStatus EMsg = 910 + EMsg_GSGetUserAchievementStatusResponse EMsg = 911 + EMsg_GSGetPlayStats EMsg = 918 + EMsg_GSGetPlayStatsResponse EMsg = 919 + EMsg_GSGetUserGroupStatus EMsg = 920 + EMsg_AMGetUserGroupStatus EMsg = 921 + EMsg_AMGetUserGroupStatusResponse EMsg = 922 + EMsg_GSGetUserGroupStatusResponse EMsg = 923 + EMsg_GSGetReputation EMsg = 936 + EMsg_GSGetReputationResponse EMsg = 937 + EMsg_GSAssociateWithClan EMsg = 938 + EMsg_GSAssociateWithClanResponse EMsg = 939 + EMsg_GSComputeNewPlayerCompatibility EMsg = 940 + EMsg_GSComputeNewPlayerCompatibilityResponse EMsg = 941 + EMsg_BaseAdmin EMsg = 1000 + EMsg_AdminCmd EMsg = 1000 + EMsg_AdminCmdResponse EMsg = 1004 + EMsg_AdminLogListenRequest EMsg = 1005 + EMsg_AdminLogEvent EMsg = 1006 + EMsg_LogSearchRequest EMsg = 1007 + EMsg_LogSearchResponse EMsg = 1008 + EMsg_LogSearchCancel EMsg = 1009 + EMsg_UniverseData EMsg = 1010 + EMsg_RequestStatHistory EMsg = 1014 + EMsg_StatHistory EMsg = 1015 + EMsg_AdminPwLogon EMsg = 1017 + EMsg_AdminPwLogonResponse EMsg = 1018 + EMsg_AdminSpew EMsg = 1019 + EMsg_AdminConsoleTitle EMsg = 1020 + EMsg_AdminGCSpew EMsg = 1023 + EMsg_AdminGCCommand EMsg = 1024 + EMsg_AdminGCGetCommandList EMsg = 1025 + EMsg_AdminGCGetCommandListResponse EMsg = 1026 + EMsg_FBSConnectionData EMsg = 1027 + EMsg_AdminMsgSpew EMsg = 1028 + EMsg_BaseFBS EMsg = 1100 + EMsg_FBSReqVersion EMsg = 1100 + EMsg_FBSVersionInfo EMsg = 1101 + EMsg_FBSForceRefresh EMsg = 1102 + EMsg_FBSForceBounce EMsg = 1103 + EMsg_FBSDeployPackage EMsg = 1104 + EMsg_FBSDeployResponse EMsg = 1105 + EMsg_FBSUpdateBootstrapper EMsg = 1106 + EMsg_FBSSetState EMsg = 1107 + EMsg_FBSApplyOSUpdates EMsg = 1108 + EMsg_FBSRunCMDScript EMsg = 1109 + EMsg_FBSRebootBox EMsg = 1110 + EMsg_FBSSetBigBrotherMode EMsg = 1111 + EMsg_FBSMinidumpServer EMsg = 1112 + EMsg_FBSSetShellCount_obsolete EMsg = 1113 // Deprecated + EMsg_FBSDeployHotFixPackage EMsg = 1114 + EMsg_FBSDeployHotFixResponse EMsg = 1115 + EMsg_FBSDownloadHotFix EMsg = 1116 + EMsg_FBSDownloadHotFixResponse EMsg = 1117 + EMsg_FBSUpdateTargetConfigFile EMsg = 1118 + EMsg_FBSApplyAccountCred EMsg = 1119 + EMsg_FBSApplyAccountCredResponse EMsg = 1120 + EMsg_FBSSetShellCount EMsg = 1121 + EMsg_FBSTerminateShell EMsg = 1122 + EMsg_FBSQueryGMForRequest EMsg = 1123 + EMsg_FBSQueryGMResponse EMsg = 1124 + EMsg_FBSTerminateZombies EMsg = 1125 + EMsg_FBSInfoFromBootstrapper EMsg = 1126 + EMsg_FBSRebootBoxResponse EMsg = 1127 + EMsg_FBSBootstrapperPackageRequest EMsg = 1128 + EMsg_FBSBootstrapperPackageResponse EMsg = 1129 + EMsg_FBSBootstrapperGetPackageChunk EMsg = 1130 + EMsg_FBSBootstrapperGetPackageChunkResponse EMsg = 1131 + EMsg_FBSBootstrapperPackageTransferProgress EMsg = 1132 + EMsg_FBSRestartBootstrapper EMsg = 1133 + EMsg_BaseFileXfer EMsg = 1200 + EMsg_FileXferRequest EMsg = 1200 + EMsg_FileXferResponse EMsg = 1201 + EMsg_FileXferData EMsg = 1202 + EMsg_FileXferEnd EMsg = 1203 + EMsg_FileXferDataAck EMsg = 1204 + EMsg_BaseChannelAuth EMsg = 1300 + EMsg_ChannelAuthChallenge EMsg = 1300 + EMsg_ChannelAuthResponse EMsg = 1301 + EMsg_ChannelAuthResult EMsg = 1302 + EMsg_ChannelEncryptRequest EMsg = 1303 + EMsg_ChannelEncryptResponse EMsg = 1304 + EMsg_ChannelEncryptResult EMsg = 1305 + EMsg_BaseBS EMsg = 1400 + EMsg_BSPurchaseStart EMsg = 1401 + EMsg_BSPurchaseResponse EMsg = 1402 + EMsg_BSSettleNOVA EMsg = 1404 + EMsg_BSSettleComplete EMsg = 1406 + EMsg_BSBannedRequest EMsg = 1407 + EMsg_BSInitPayPalTxn EMsg = 1408 + EMsg_BSInitPayPalTxnResponse EMsg = 1409 + EMsg_BSGetPayPalUserInfo EMsg = 1410 + EMsg_BSGetPayPalUserInfoResponse EMsg = 1411 + EMsg_BSRefundTxn EMsg = 1413 + EMsg_BSRefundTxnResponse EMsg = 1414 + EMsg_BSGetEvents EMsg = 1415 + EMsg_BSChaseRFRRequest EMsg = 1416 + EMsg_BSPaymentInstrBan EMsg = 1417 + EMsg_BSPaymentInstrBanResponse EMsg = 1418 + EMsg_BSProcessGCReports EMsg = 1419 + EMsg_BSProcessPPReports EMsg = 1420 + EMsg_BSInitGCBankXferTxn EMsg = 1421 + EMsg_BSInitGCBankXferTxnResponse EMsg = 1422 + EMsg_BSQueryGCBankXferTxn EMsg = 1423 + EMsg_BSQueryGCBankXferTxnResponse EMsg = 1424 + EMsg_BSCommitGCTxn EMsg = 1425 + EMsg_BSQueryTransactionStatus EMsg = 1426 + EMsg_BSQueryTransactionStatusResponse EMsg = 1427 + EMsg_BSQueryCBOrderStatus EMsg = 1428 + EMsg_BSQueryCBOrderStatusResponse EMsg = 1429 + EMsg_BSRunRedFlagReport EMsg = 1430 + EMsg_BSQueryPaymentInstUsage EMsg = 1431 + EMsg_BSQueryPaymentInstResponse EMsg = 1432 + EMsg_BSQueryTxnExtendedInfo EMsg = 1433 + EMsg_BSQueryTxnExtendedInfoResponse EMsg = 1434 + EMsg_BSUpdateConversionRates EMsg = 1435 + EMsg_BSProcessUSBankReports EMsg = 1436 + EMsg_BSPurchaseRunFraudChecks EMsg = 1437 + EMsg_BSPurchaseRunFraudChecksResponse EMsg = 1438 + EMsg_BSStartShippingJobs EMsg = 1439 + EMsg_BSQueryBankInformation EMsg = 1440 + EMsg_BSQueryBankInformationResponse EMsg = 1441 + EMsg_BSValidateXsollaSignature EMsg = 1445 + EMsg_BSValidateXsollaSignatureResponse EMsg = 1446 + EMsg_BSQiwiWalletInvoice EMsg = 1448 + EMsg_BSQiwiWalletInvoiceResponse EMsg = 1449 + EMsg_BSUpdateInventoryFromProPack EMsg = 1450 + EMsg_BSUpdateInventoryFromProPackResponse EMsg = 1451 + EMsg_BSSendShippingRequest EMsg = 1452 + EMsg_BSSendShippingRequestResponse EMsg = 1453 + EMsg_BSGetProPackOrderStatus EMsg = 1454 + EMsg_BSGetProPackOrderStatusResponse EMsg = 1455 + EMsg_BSCheckJobRunning EMsg = 1456 + EMsg_BSCheckJobRunningResponse EMsg = 1457 + EMsg_BSResetPackagePurchaseRateLimit EMsg = 1458 + EMsg_BSResetPackagePurchaseRateLimitResponse EMsg = 1459 + EMsg_BSUpdatePaymentData EMsg = 1460 + EMsg_BSUpdatePaymentDataResponse EMsg = 1461 + EMsg_BSGetBillingAddress EMsg = 1462 + EMsg_BSGetBillingAddressResponse EMsg = 1463 + EMsg_BSGetCreditCardInfo EMsg = 1464 + EMsg_BSGetCreditCardInfoResponse EMsg = 1465 + EMsg_BSRemoveExpiredPaymentData EMsg = 1468 + EMsg_BSRemoveExpiredPaymentDataResponse EMsg = 1469 + EMsg_BSConvertToCurrentKeys EMsg = 1470 + EMsg_BSConvertToCurrentKeysResponse EMsg = 1471 + EMsg_BSInitPurchase EMsg = 1472 + EMsg_BSInitPurchaseResponse EMsg = 1473 + EMsg_BSCompletePurchase EMsg = 1474 + EMsg_BSCompletePurchaseResponse EMsg = 1475 + EMsg_BSPruneCardUsageStats EMsg = 1476 + EMsg_BSPruneCardUsageStatsResponse EMsg = 1477 + EMsg_BSStoreBankInformation EMsg = 1478 + EMsg_BSStoreBankInformationResponse EMsg = 1479 + EMsg_BSVerifyPOSAKey EMsg = 1480 + EMsg_BSVerifyPOSAKeyResponse EMsg = 1481 + EMsg_BSReverseRedeemPOSAKey EMsg = 1482 + EMsg_BSReverseRedeemPOSAKeyResponse EMsg = 1483 + EMsg_BSQueryFindCreditCard EMsg = 1484 + EMsg_BSQueryFindCreditCardResponse EMsg = 1485 + EMsg_BSStatusInquiryPOSAKey EMsg = 1486 + EMsg_BSStatusInquiryPOSAKeyResponse EMsg = 1487 + EMsg_BSValidateMoPaySignature EMsg = 1488 + EMsg_BSValidateMoPaySignatureResponse EMsg = 1489 + EMsg_BSMoPayConfirmProductDelivery EMsg = 1490 + EMsg_BSMoPayConfirmProductDeliveryResponse EMsg = 1491 + EMsg_BSGenerateMoPayMD5 EMsg = 1492 + EMsg_BSGenerateMoPayMD5Response EMsg = 1493 + EMsg_BSBoaCompraConfirmProductDelivery EMsg = 1494 + EMsg_BSBoaCompraConfirmProductDeliveryResponse EMsg = 1495 + EMsg_BSGenerateBoaCompraMD5 EMsg = 1496 + EMsg_BSGenerateBoaCompraMD5Response EMsg = 1497 + EMsg_BaseATS EMsg = 1500 + EMsg_ATSStartStressTest EMsg = 1501 + EMsg_ATSStopStressTest EMsg = 1502 + EMsg_ATSRunFailServerTest EMsg = 1503 + EMsg_ATSUFSPerfTestTask EMsg = 1504 + EMsg_ATSUFSPerfTestResponse EMsg = 1505 + EMsg_ATSCycleTCM EMsg = 1506 + EMsg_ATSInitDRMSStressTest EMsg = 1507 + EMsg_ATSCallTest EMsg = 1508 + EMsg_ATSCallTestReply EMsg = 1509 + EMsg_ATSStartExternalStress EMsg = 1510 + EMsg_ATSExternalStressJobStart EMsg = 1511 + EMsg_ATSExternalStressJobQueued EMsg = 1512 + EMsg_ATSExternalStressJobRunning EMsg = 1513 + EMsg_ATSExternalStressJobStopped EMsg = 1514 + EMsg_ATSExternalStressJobStopAll EMsg = 1515 + EMsg_ATSExternalStressActionResult EMsg = 1516 + EMsg_ATSStarted EMsg = 1517 + EMsg_ATSCSPerfTestTask EMsg = 1518 + EMsg_ATSCSPerfTestResponse EMsg = 1519 + EMsg_BaseDP EMsg = 1600 + EMsg_DPSetPublishingState EMsg = 1601 + EMsg_DPGamePlayedStats EMsg = 1602 + EMsg_DPUniquePlayersStat EMsg = 1603 + EMsg_DPVacInfractionStats EMsg = 1605 + EMsg_DPVacBanStats EMsg = 1606 + EMsg_DPBlockingStats EMsg = 1607 + EMsg_DPNatTraversalStats EMsg = 1608 + EMsg_DPSteamUsageEvent EMsg = 1609 + EMsg_DPVacCertBanStats EMsg = 1610 + EMsg_DPVacCafeBanStats EMsg = 1611 + EMsg_DPCloudStats EMsg = 1612 + EMsg_DPAchievementStats EMsg = 1613 + EMsg_DPAccountCreationStats EMsg = 1614 + EMsg_DPGetPlayerCount EMsg = 1615 + EMsg_DPGetPlayerCountResponse EMsg = 1616 + EMsg_DPGameServersPlayersStats EMsg = 1617 + EMsg_DPDownloadRateStatistics EMsg = 1618 + EMsg_DPFacebookStatistics EMsg = 1619 + EMsg_ClientDPCheckSpecialSurvey EMsg = 1620 + EMsg_ClientDPCheckSpecialSurveyResponse EMsg = 1621 + EMsg_ClientDPSendSpecialSurveyResponse EMsg = 1622 + EMsg_ClientDPSendSpecialSurveyResponseReply EMsg = 1623 + EMsg_DPStoreSaleStatistics EMsg = 1624 + EMsg_ClientDPUpdateAppJobReport EMsg = 1625 + EMsg_ClientDPSteam2AppStarted EMsg = 1627 // Deprecated + EMsg_DPUpdateContentEvent EMsg = 1626 + EMsg_ClientDPContentStatsReport EMsg = 1630 + EMsg_BaseCM EMsg = 1700 + EMsg_CMSetAllowState EMsg = 1701 + EMsg_CMSpewAllowState EMsg = 1702 + EMsg_CMAppInfoResponseDeprecated EMsg = 1703 // Deprecated + EMsg_BaseDSS EMsg = 1800 + EMsg_DSSNewFile EMsg = 1801 + EMsg_DSSCurrentFileList EMsg = 1802 + EMsg_DSSSynchList EMsg = 1803 + EMsg_DSSSynchListResponse EMsg = 1804 + EMsg_DSSSynchSubscribe EMsg = 1805 + EMsg_DSSSynchUnsubscribe EMsg = 1806 + EMsg_BaseEPM EMsg = 1900 + EMsg_EPMStartProcess EMsg = 1901 + EMsg_EPMStopProcess EMsg = 1902 + EMsg_EPMRestartProcess EMsg = 1903 + EMsg_BaseGC EMsg = 2200 + EMsg_GCSendClient EMsg = 2200 + EMsg_AMRelayToGC EMsg = 2201 + EMsg_GCUpdatePlayedState EMsg = 2202 + EMsg_GCCmdRevive EMsg = 2203 + EMsg_GCCmdBounce EMsg = 2204 + EMsg_GCCmdForceBounce EMsg = 2205 + EMsg_GCCmdDown EMsg = 2206 + EMsg_GCCmdDeploy EMsg = 2207 + EMsg_GCCmdDeployResponse EMsg = 2208 + EMsg_GCCmdSwitch EMsg = 2209 + EMsg_AMRefreshSessions EMsg = 2210 + EMsg_GCUpdateGSState EMsg = 2211 + EMsg_GCAchievementAwarded EMsg = 2212 + EMsg_GCSystemMessage EMsg = 2213 + EMsg_GCValidateSession EMsg = 2214 + EMsg_GCValidateSessionResponse EMsg = 2215 + EMsg_GCCmdStatus EMsg = 2216 + EMsg_GCRegisterWebInterfaces EMsg = 2217 // Deprecated + EMsg_GCRegisterWebInterfaces_Deprecated EMsg = 2217 // Deprecated + EMsg_GCGetAccountDetails EMsg = 2218 // Deprecated + EMsg_GCGetAccountDetails_DEPRECATED EMsg = 2218 // Deprecated + EMsg_GCInterAppMessage EMsg = 2219 + EMsg_GCGetEmailTemplate EMsg = 2220 + EMsg_GCGetEmailTemplateResponse EMsg = 2221 + EMsg_ISRelayToGCH EMsg = 2222 + EMsg_GCHRelayClientToIS EMsg = 2223 + EMsg_GCHUpdateSession EMsg = 2224 + EMsg_GCHRequestUpdateSession EMsg = 2225 + EMsg_GCHRequestStatus EMsg = 2226 + EMsg_GCHRequestStatusResponse EMsg = 2227 + EMsg_BaseP2P EMsg = 2500 + EMsg_P2PIntroducerMessage EMsg = 2502 + EMsg_BaseSM EMsg = 2900 + EMsg_SMExpensiveReport EMsg = 2902 + EMsg_SMHourlyReport EMsg = 2903 + EMsg_SMFishingReport EMsg = 2904 + EMsg_SMPartitionRenames EMsg = 2905 + EMsg_SMMonitorSpace EMsg = 2906 + EMsg_SMGetSchemaConversionResults EMsg = 2907 + EMsg_SMGetSchemaConversionResultsResponse EMsg = 2908 + EMsg_BaseTest EMsg = 3000 + EMsg_FailServer EMsg = 3000 + EMsg_JobHeartbeatTest EMsg = 3001 + EMsg_JobHeartbeatTestResponse EMsg = 3002 + EMsg_BaseFTSRange EMsg = 3100 + EMsg_FTSGetBrowseCounts EMsg = 3101 + EMsg_FTSGetBrowseCountsResponse EMsg = 3102 + EMsg_FTSBrowseClans EMsg = 3103 + EMsg_FTSBrowseClansResponse EMsg = 3104 + EMsg_FTSSearchClansByLocation EMsg = 3105 + EMsg_FTSSearchClansByLocationResponse EMsg = 3106 + EMsg_FTSSearchPlayersByLocation EMsg = 3107 + EMsg_FTSSearchPlayersByLocationResponse EMsg = 3108 + EMsg_FTSClanDeleted EMsg = 3109 + EMsg_FTSSearch EMsg = 3110 + EMsg_FTSSearchResponse EMsg = 3111 + EMsg_FTSSearchStatus EMsg = 3112 + EMsg_FTSSearchStatusResponse EMsg = 3113 + EMsg_FTSGetGSPlayStats EMsg = 3114 + EMsg_FTSGetGSPlayStatsResponse EMsg = 3115 + EMsg_FTSGetGSPlayStatsForServer EMsg = 3116 + EMsg_FTSGetGSPlayStatsForServerResponse EMsg = 3117 + EMsg_FTSReportIPUpdates EMsg = 3118 + EMsg_BaseCCSRange EMsg = 3150 + EMsg_CCSGetComments EMsg = 3151 + EMsg_CCSGetCommentsResponse EMsg = 3152 + EMsg_CCSAddComment EMsg = 3153 + EMsg_CCSAddCommentResponse EMsg = 3154 + EMsg_CCSDeleteComment EMsg = 3155 + EMsg_CCSDeleteCommentResponse EMsg = 3156 + EMsg_CCSPreloadComments EMsg = 3157 + EMsg_CCSNotifyCommentCount EMsg = 3158 + EMsg_CCSGetCommentsForNews EMsg = 3159 + EMsg_CCSGetCommentsForNewsResponse EMsg = 3160 + EMsg_CCSDeleteAllCommentsByAuthor EMsg = 3161 + EMsg_CCSDeleteAllCommentsByAuthorResponse EMsg = 3162 + EMsg_BaseLBSRange EMsg = 3200 + EMsg_LBSSetScore EMsg = 3201 + EMsg_LBSSetScoreResponse EMsg = 3202 + EMsg_LBSFindOrCreateLB EMsg = 3203 + EMsg_LBSFindOrCreateLBResponse EMsg = 3204 + EMsg_LBSGetLBEntries EMsg = 3205 + EMsg_LBSGetLBEntriesResponse EMsg = 3206 + EMsg_LBSGetLBList EMsg = 3207 + EMsg_LBSGetLBListResponse EMsg = 3208 + EMsg_LBSSetLBDetails EMsg = 3209 + EMsg_LBSDeleteLB EMsg = 3210 + EMsg_LBSDeleteLBEntry EMsg = 3211 + EMsg_LBSResetLB EMsg = 3212 + EMsg_BaseOGS EMsg = 3400 + EMsg_OGSBeginSession EMsg = 3401 + EMsg_OGSBeginSessionResponse EMsg = 3402 + EMsg_OGSEndSession EMsg = 3403 + EMsg_OGSEndSessionResponse EMsg = 3404 + EMsg_OGSWriteAppSessionRow EMsg = 3406 + EMsg_BaseBRP EMsg = 3600 + EMsg_BRPStartShippingJobs EMsg = 3601 + EMsg_BRPProcessUSBankReports EMsg = 3602 + EMsg_BRPProcessGCReports EMsg = 3603 + EMsg_BRPProcessPPReports EMsg = 3604 + EMsg_BRPSettleNOVA EMsg = 3605 + EMsg_BRPSettleCB EMsg = 3606 + EMsg_BRPCommitGC EMsg = 3607 + EMsg_BRPCommitGCResponse EMsg = 3608 + EMsg_BRPFindHungTransactions EMsg = 3609 + EMsg_BRPCheckFinanceCloseOutDate EMsg = 3610 + EMsg_BRPProcessLicenses EMsg = 3611 + EMsg_BRPProcessLicensesResponse EMsg = 3612 + EMsg_BRPRemoveExpiredPaymentData EMsg = 3613 + EMsg_BRPRemoveExpiredPaymentDataResponse EMsg = 3614 + EMsg_BRPConvertToCurrentKeys EMsg = 3615 + EMsg_BRPConvertToCurrentKeysResponse EMsg = 3616 + EMsg_BRPPruneCardUsageStats EMsg = 3617 + EMsg_BRPPruneCardUsageStatsResponse EMsg = 3618 + EMsg_BRPCheckActivationCodes EMsg = 3619 + EMsg_BRPCheckActivationCodesResponse EMsg = 3620 + EMsg_BaseAMRange2 EMsg = 4000 + EMsg_AMCreateChat EMsg = 4001 + EMsg_AMCreateChatResponse EMsg = 4002 + EMsg_AMUpdateChatMetadata EMsg = 4003 + EMsg_AMPublishChatMetadata EMsg = 4004 + EMsg_AMSetProfileURL EMsg = 4005 + EMsg_AMGetAccountEmailAddress EMsg = 4006 + EMsg_AMGetAccountEmailAddressResponse EMsg = 4007 + EMsg_AMRequestFriendData EMsg = 4008 + EMsg_AMRouteToClients EMsg = 4009 + EMsg_AMLeaveClan EMsg = 4010 + EMsg_AMClanPermissions EMsg = 4011 + EMsg_AMClanPermissionsResponse EMsg = 4012 + EMsg_AMCreateClanEvent EMsg = 4013 + EMsg_AMCreateClanEventResponse EMsg = 4014 + EMsg_AMUpdateClanEvent EMsg = 4015 + EMsg_AMUpdateClanEventResponse EMsg = 4016 + EMsg_AMGetClanEvents EMsg = 4017 + EMsg_AMGetClanEventsResponse EMsg = 4018 + EMsg_AMDeleteClanEvent EMsg = 4019 + EMsg_AMDeleteClanEventResponse EMsg = 4020 + EMsg_AMSetClanPermissionSettings EMsg = 4021 + EMsg_AMSetClanPermissionSettingsResponse EMsg = 4022 + EMsg_AMGetClanPermissionSettings EMsg = 4023 + EMsg_AMGetClanPermissionSettingsResponse EMsg = 4024 + EMsg_AMPublishChatRoomInfo EMsg = 4025 + EMsg_ClientChatRoomInfo EMsg = 4026 + EMsg_AMCreateClanAnnouncement EMsg = 4027 + EMsg_AMCreateClanAnnouncementResponse EMsg = 4028 + EMsg_AMUpdateClanAnnouncement EMsg = 4029 + EMsg_AMUpdateClanAnnouncementResponse EMsg = 4030 + EMsg_AMGetClanAnnouncementsCount EMsg = 4031 + EMsg_AMGetClanAnnouncementsCountResponse EMsg = 4032 + EMsg_AMGetClanAnnouncements EMsg = 4033 + EMsg_AMGetClanAnnouncementsResponse EMsg = 4034 + EMsg_AMDeleteClanAnnouncement EMsg = 4035 + EMsg_AMDeleteClanAnnouncementResponse EMsg = 4036 + EMsg_AMGetSingleClanAnnouncement EMsg = 4037 + EMsg_AMGetSingleClanAnnouncementResponse EMsg = 4038 + EMsg_AMGetClanHistory EMsg = 4039 + EMsg_AMGetClanHistoryResponse EMsg = 4040 + EMsg_AMGetClanPermissionBits EMsg = 4041 + EMsg_AMGetClanPermissionBitsResponse EMsg = 4042 + EMsg_AMSetClanPermissionBits EMsg = 4043 + EMsg_AMSetClanPermissionBitsResponse EMsg = 4044 + EMsg_AMSessionInfoRequest EMsg = 4045 + EMsg_AMSessionInfoResponse EMsg = 4046 + EMsg_AMValidateWGToken EMsg = 4047 + EMsg_AMGetSingleClanEvent EMsg = 4048 + EMsg_AMGetSingleClanEventResponse EMsg = 4049 + EMsg_AMGetClanRank EMsg = 4050 + EMsg_AMGetClanRankResponse EMsg = 4051 + EMsg_AMSetClanRank EMsg = 4052 + EMsg_AMSetClanRankResponse EMsg = 4053 + EMsg_AMGetClanPOTW EMsg = 4054 + EMsg_AMGetClanPOTWResponse EMsg = 4055 + EMsg_AMSetClanPOTW EMsg = 4056 + EMsg_AMSetClanPOTWResponse EMsg = 4057 + EMsg_AMRequestChatMetadata EMsg = 4058 + EMsg_AMDumpUser EMsg = 4059 + EMsg_AMKickUserFromClan EMsg = 4060 + EMsg_AMAddFounderToClan EMsg = 4061 + EMsg_AMValidateWGTokenResponse EMsg = 4062 + EMsg_AMSetCommunityState EMsg = 4063 + EMsg_AMSetAccountDetails EMsg = 4064 + EMsg_AMGetChatBanList EMsg = 4065 + EMsg_AMGetChatBanListResponse EMsg = 4066 + EMsg_AMUnBanFromChat EMsg = 4067 + EMsg_AMSetClanDetails EMsg = 4068 + EMsg_AMGetAccountLinks EMsg = 4069 + EMsg_AMGetAccountLinksResponse EMsg = 4070 + EMsg_AMSetAccountLinks EMsg = 4071 + EMsg_AMSetAccountLinksResponse EMsg = 4072 + EMsg_AMGetUserGameStats EMsg = 4073 + EMsg_AMGetUserGameStatsResponse EMsg = 4074 + EMsg_AMCheckClanMembership EMsg = 4075 + EMsg_AMGetClanMembers EMsg = 4076 + EMsg_AMGetClanMembersResponse EMsg = 4077 + EMsg_AMJoinPublicClan EMsg = 4078 + EMsg_AMNotifyChatOfClanChange EMsg = 4079 + EMsg_AMResubmitPurchase EMsg = 4080 + EMsg_AMAddFriend EMsg = 4081 + EMsg_AMAddFriendResponse EMsg = 4082 + EMsg_AMRemoveFriend EMsg = 4083 + EMsg_AMDumpClan EMsg = 4084 + EMsg_AMChangeClanOwner EMsg = 4085 + EMsg_AMCancelEasyCollect EMsg = 4086 + EMsg_AMCancelEasyCollectResponse EMsg = 4087 + EMsg_AMGetClanMembershipList EMsg = 4088 + EMsg_AMGetClanMembershipListResponse EMsg = 4089 + EMsg_AMClansInCommon EMsg = 4090 + EMsg_AMClansInCommonResponse EMsg = 4091 + EMsg_AMIsValidAccountID EMsg = 4092 + EMsg_AMConvertClan EMsg = 4093 + EMsg_AMGetGiftTargetListRelay EMsg = 4094 + EMsg_AMWipeFriendsList EMsg = 4095 + EMsg_AMSetIgnored EMsg = 4096 + EMsg_AMClansInCommonCountResponse EMsg = 4097 + EMsg_AMFriendsList EMsg = 4098 + EMsg_AMFriendsListResponse EMsg = 4099 + EMsg_AMFriendsInCommon EMsg = 4100 + EMsg_AMFriendsInCommonResponse EMsg = 4101 + EMsg_AMFriendsInCommonCountResponse EMsg = 4102 + EMsg_AMClansInCommonCount EMsg = 4103 + EMsg_AMChallengeVerdict EMsg = 4104 + EMsg_AMChallengeNotification EMsg = 4105 + EMsg_AMFindGSByIP EMsg = 4106 + EMsg_AMFoundGSByIP EMsg = 4107 + EMsg_AMGiftRevoked EMsg = 4108 + EMsg_AMCreateAccountRecord EMsg = 4109 + EMsg_AMUserClanList EMsg = 4110 + EMsg_AMUserClanListResponse EMsg = 4111 + EMsg_AMGetAccountDetails2 EMsg = 4112 + EMsg_AMGetAccountDetailsResponse2 EMsg = 4113 + EMsg_AMSetCommunityProfileSettings EMsg = 4114 + EMsg_AMSetCommunityProfileSettingsResponse EMsg = 4115 + EMsg_AMGetCommunityPrivacyState EMsg = 4116 + EMsg_AMGetCommunityPrivacyStateResponse EMsg = 4117 + EMsg_AMCheckClanInviteRateLimiting EMsg = 4118 + EMsg_AMGetUserAchievementStatus EMsg = 4119 + EMsg_AMGetIgnored EMsg = 4120 + EMsg_AMGetIgnoredResponse EMsg = 4121 + EMsg_AMSetIgnoredResponse EMsg = 4122 + EMsg_AMSetFriendRelationshipNone EMsg = 4123 + EMsg_AMGetFriendRelationship EMsg = 4124 + EMsg_AMGetFriendRelationshipResponse EMsg = 4125 + EMsg_AMServiceModulesCache EMsg = 4126 + EMsg_AMServiceModulesCall EMsg = 4127 + EMsg_AMServiceModulesCallResponse EMsg = 4128 + EMsg_AMGetCaptchaDataForIP EMsg = 4129 + EMsg_AMGetCaptchaDataForIPResponse EMsg = 4130 + EMsg_AMValidateCaptchaDataForIP EMsg = 4131 + EMsg_AMValidateCaptchaDataForIPResponse EMsg = 4132 + EMsg_AMTrackFailedAuthByIP EMsg = 4133 + EMsg_AMGetCaptchaDataByGID EMsg = 4134 + EMsg_AMGetCaptchaDataByGIDResponse EMsg = 4135 + EMsg_AMGetLobbyList EMsg = 4136 + EMsg_AMGetLobbyListResponse EMsg = 4137 + EMsg_AMGetLobbyMetadata EMsg = 4138 + EMsg_AMGetLobbyMetadataResponse EMsg = 4139 + EMsg_CommunityAddFriendNews EMsg = 4140 + EMsg_AMAddClanNews EMsg = 4141 + EMsg_AMWriteNews EMsg = 4142 + EMsg_AMFindClanUser EMsg = 4143 + EMsg_AMFindClanUserResponse EMsg = 4144 + EMsg_AMBanFromChat EMsg = 4145 + EMsg_AMGetUserHistoryResponse EMsg = 4146 + EMsg_AMGetUserNewsSubscriptions EMsg = 4147 + EMsg_AMGetUserNewsSubscriptionsResponse EMsg = 4148 + EMsg_AMSetUserNewsSubscriptions EMsg = 4149 + EMsg_AMGetUserNews EMsg = 4150 + EMsg_AMGetUserNewsResponse EMsg = 4151 + EMsg_AMSendQueuedEmails EMsg = 4152 + EMsg_AMSetLicenseFlags EMsg = 4153 + EMsg_AMGetUserHistory EMsg = 4154 + EMsg_CommunityDeleteUserNews EMsg = 4155 + EMsg_AMAllowUserFilesRequest EMsg = 4156 + EMsg_AMAllowUserFilesResponse EMsg = 4157 + EMsg_AMGetAccountStatus EMsg = 4158 + EMsg_AMGetAccountStatusResponse EMsg = 4159 + EMsg_AMEditBanReason EMsg = 4160 + EMsg_AMCheckClanMembershipResponse EMsg = 4161 + EMsg_AMProbeClanMembershipList EMsg = 4162 + EMsg_AMProbeClanMembershipListResponse EMsg = 4163 + EMsg_AMGetFriendsLobbies EMsg = 4165 + EMsg_AMGetFriendsLobbiesResponse EMsg = 4166 + EMsg_AMGetUserFriendNewsResponse EMsg = 4172 + EMsg_CommunityGetUserFriendNews EMsg = 4173 + EMsg_AMGetUserClansNewsResponse EMsg = 4174 + EMsg_AMGetUserClansNews EMsg = 4175 + EMsg_AMStoreInitPurchase EMsg = 4176 + EMsg_AMStoreInitPurchaseResponse EMsg = 4177 + EMsg_AMStoreGetFinalPrice EMsg = 4178 + EMsg_AMStoreGetFinalPriceResponse EMsg = 4179 + EMsg_AMStoreCompletePurchase EMsg = 4180 + EMsg_AMStoreCancelPurchase EMsg = 4181 + EMsg_AMStorePurchaseResponse EMsg = 4182 + EMsg_AMCreateAccountRecordInSteam3 EMsg = 4183 + EMsg_AMGetPreviousCBAccount EMsg = 4184 + EMsg_AMGetPreviousCBAccountResponse EMsg = 4185 + EMsg_AMUpdateBillingAddress EMsg = 4186 + EMsg_AMUpdateBillingAddressResponse EMsg = 4187 + EMsg_AMGetBillingAddress EMsg = 4188 + EMsg_AMGetBillingAddressResponse EMsg = 4189 + EMsg_AMGetUserLicenseHistory EMsg = 4190 + EMsg_AMGetUserLicenseHistoryResponse EMsg = 4191 + EMsg_AMSupportChangePassword EMsg = 4194 + EMsg_AMSupportChangeEmail EMsg = 4195 + EMsg_AMSupportChangeSecretQA EMsg = 4196 + EMsg_AMResetUserVerificationGSByIP EMsg = 4197 + EMsg_AMUpdateGSPlayStats EMsg = 4198 + EMsg_AMSupportEnableOrDisable EMsg = 4199 + EMsg_AMGetComments EMsg = 4200 + EMsg_AMGetCommentsResponse EMsg = 4201 + EMsg_AMAddComment EMsg = 4202 + EMsg_AMAddCommentResponse EMsg = 4203 + EMsg_AMDeleteComment EMsg = 4204 + EMsg_AMDeleteCommentResponse EMsg = 4205 + EMsg_AMGetPurchaseStatus EMsg = 4206 + EMsg_AMSupportIsAccountEnabled EMsg = 4209 + EMsg_AMSupportIsAccountEnabledResponse EMsg = 4210 + EMsg_AMGetUserStats EMsg = 4211 + EMsg_AMSupportKickSession EMsg = 4212 + EMsg_AMGSSearch EMsg = 4213 + EMsg_MarketingMessageUpdate EMsg = 4216 + EMsg_AMRouteFriendMsg EMsg = 4219 + EMsg_AMTicketAuthRequestOrResponse EMsg = 4220 + EMsg_AMVerifyDepotManagementRights EMsg = 4222 + EMsg_AMVerifyDepotManagementRightsResponse EMsg = 4223 + EMsg_AMAddFreeLicense EMsg = 4224 + EMsg_AMGetUserFriendsMinutesPlayed EMsg = 4225 + EMsg_AMGetUserFriendsMinutesPlayedResponse EMsg = 4226 + EMsg_AMGetUserMinutesPlayed EMsg = 4227 + EMsg_AMGetUserMinutesPlayedResponse EMsg = 4228 + EMsg_AMValidateEmailLink EMsg = 4231 + EMsg_AMValidateEmailLinkResponse EMsg = 4232 + EMsg_AMAddUsersToMarketingTreatment EMsg = 4234 + EMsg_AMStoreUserStats EMsg = 4236 + EMsg_AMGetUserGameplayInfo EMsg = 4237 + EMsg_AMGetUserGameplayInfoResponse EMsg = 4238 + EMsg_AMGetCardList EMsg = 4239 + EMsg_AMGetCardListResponse EMsg = 4240 + EMsg_AMDeleteStoredCard EMsg = 4241 + EMsg_AMRevokeLegacyGameKeys EMsg = 4242 + EMsg_AMGetWalletDetails EMsg = 4244 + EMsg_AMGetWalletDetailsResponse EMsg = 4245 + EMsg_AMDeleteStoredPaymentInfo EMsg = 4246 + EMsg_AMGetStoredPaymentSummary EMsg = 4247 + EMsg_AMGetStoredPaymentSummaryResponse EMsg = 4248 + EMsg_AMGetWalletConversionRate EMsg = 4249 + EMsg_AMGetWalletConversionRateResponse EMsg = 4250 + EMsg_AMConvertWallet EMsg = 4251 + EMsg_AMConvertWalletResponse EMsg = 4252 + EMsg_AMRelayGetFriendsWhoPlayGame EMsg = 4253 + EMsg_AMRelayGetFriendsWhoPlayGameResponse EMsg = 4254 + EMsg_AMSetPreApproval EMsg = 4255 + EMsg_AMSetPreApprovalResponse EMsg = 4256 + EMsg_AMMarketingTreatmentUpdate EMsg = 4257 + EMsg_AMCreateRefund EMsg = 4258 + EMsg_AMCreateRefundResponse EMsg = 4259 + EMsg_AMCreateChargeback EMsg = 4260 + EMsg_AMCreateChargebackResponse EMsg = 4261 + EMsg_AMCreateDispute EMsg = 4262 + EMsg_AMCreateDisputeResponse EMsg = 4263 + EMsg_AMClearDispute EMsg = 4264 + EMsg_AMClearDisputeResponse EMsg = 4265 + EMsg_AMPlayerNicknameList EMsg = 4266 + EMsg_AMPlayerNicknameListResponse EMsg = 4267 + EMsg_AMSetDRMTestConfig EMsg = 4268 + EMsg_AMGetUserCurrentGameInfo EMsg = 4269 + EMsg_AMGetUserCurrentGameInfoResponse EMsg = 4270 + EMsg_AMGetGSPlayerList EMsg = 4271 + EMsg_AMGetGSPlayerListResponse EMsg = 4272 + EMsg_AMUpdatePersonaStateCache EMsg = 4275 + EMsg_AMGetGameMembers EMsg = 4276 + EMsg_AMGetGameMembersResponse EMsg = 4277 + EMsg_AMGetSteamIDForMicroTxn EMsg = 4278 + EMsg_AMGetSteamIDForMicroTxnResponse EMsg = 4279 + EMsg_AMAddPublisherUser EMsg = 4280 + EMsg_AMRemovePublisherUser EMsg = 4281 + EMsg_AMGetUserLicenseList EMsg = 4282 + EMsg_AMGetUserLicenseListResponse EMsg = 4283 + EMsg_AMReloadGameGroupPolicy EMsg = 4284 + EMsg_AMAddFreeLicenseResponse EMsg = 4285 + EMsg_AMVACStatusUpdate EMsg = 4286 + EMsg_AMGetAccountDetails EMsg = 4287 + EMsg_AMGetAccountDetailsResponse EMsg = 4288 + EMsg_AMGetPlayerLinkDetails EMsg = 4289 + EMsg_AMGetPlayerLinkDetailsResponse EMsg = 4290 + EMsg_AMSubscribeToPersonaFeed EMsg = 4291 + EMsg_AMGetUserVacBanList EMsg = 4292 + EMsg_AMGetUserVacBanListResponse EMsg = 4293 + EMsg_AMGetAccountFlagsForWGSpoofing EMsg = 4294 + EMsg_AMGetAccountFlagsForWGSpoofingResponse EMsg = 4295 + EMsg_AMGetFriendsWishlistInfo EMsg = 4296 + EMsg_AMGetFriendsWishlistInfoResponse EMsg = 4297 + EMsg_AMGetClanOfficers EMsg = 4298 + EMsg_AMGetClanOfficersResponse EMsg = 4299 + EMsg_AMNameChange EMsg = 4300 + EMsg_AMGetNameHistory EMsg = 4301 + EMsg_AMGetNameHistoryResponse EMsg = 4302 + EMsg_AMUpdateProviderStatus EMsg = 4305 + EMsg_AMClearPersonaMetadataBlob EMsg = 4306 + EMsg_AMSupportRemoveAccountSecurity EMsg = 4307 + EMsg_AMIsAccountInCaptchaGracePeriod EMsg = 4308 + EMsg_AMIsAccountInCaptchaGracePeriodResponse EMsg = 4309 + EMsg_AMAccountPS3Unlink EMsg = 4310 + EMsg_AMAccountPS3UnlinkResponse EMsg = 4311 + EMsg_AMStoreUserStatsResponse EMsg = 4312 + EMsg_AMGetAccountPSNInfo EMsg = 4313 + EMsg_AMGetAccountPSNInfoResponse EMsg = 4314 + EMsg_AMAuthenticatedPlayerList EMsg = 4315 + EMsg_AMGetUserGifts EMsg = 4316 + EMsg_AMGetUserGiftsResponse EMsg = 4317 + EMsg_AMTransferLockedGifts EMsg = 4320 + EMsg_AMTransferLockedGiftsResponse EMsg = 4321 + EMsg_AMPlayerHostedOnGameServer EMsg = 4322 + EMsg_AMGetAccountBanInfo EMsg = 4323 + EMsg_AMGetAccountBanInfoResponse EMsg = 4324 + EMsg_AMRecordBanEnforcement EMsg = 4325 + EMsg_AMRollbackGiftTransfer EMsg = 4326 + EMsg_AMRollbackGiftTransferResponse EMsg = 4327 + EMsg_AMHandlePendingTransaction EMsg = 4328 + EMsg_AMRequestClanDetails EMsg = 4329 + EMsg_AMDeleteStoredPaypalAgreement EMsg = 4330 + EMsg_AMGameServerUpdate EMsg = 4331 + EMsg_AMGameServerRemove EMsg = 4332 + EMsg_AMGetPaypalAgreements EMsg = 4333 + EMsg_AMGetPaypalAgreementsResponse EMsg = 4334 + EMsg_AMGameServerPlayerCompatibilityCheck EMsg = 4335 + EMsg_AMGameServerPlayerCompatibilityCheckResponse EMsg = 4336 + EMsg_AMRenewLicense EMsg = 4337 + EMsg_AMGetAccountCommunityBanInfo EMsg = 4338 + EMsg_AMGetAccountCommunityBanInfoResponse EMsg = 4339 + EMsg_AMGameServerAccountChangePassword EMsg = 4340 + EMsg_AMGameServerAccountDeleteAccount EMsg = 4341 + EMsg_AMRenewAgreement EMsg = 4342 + EMsg_AMSendEmail EMsg = 4343 + EMsg_AMXsollaPayment EMsg = 4344 + EMsg_AMXsollaPaymentResponse EMsg = 4345 + EMsg_AMAcctAllowedToPurchase EMsg = 4346 + EMsg_AMAcctAllowedToPurchaseResponse EMsg = 4347 + EMsg_AMSwapKioskDeposit EMsg = 4348 + EMsg_AMSwapKioskDepositResponse EMsg = 4349 + EMsg_AMSetUserGiftUnowned EMsg = 4350 + EMsg_AMSetUserGiftUnownedResponse EMsg = 4351 + EMsg_AMClaimUnownedUserGift EMsg = 4352 + EMsg_AMClaimUnownedUserGiftResponse EMsg = 4353 + EMsg_AMSetClanName EMsg = 4354 + EMsg_AMSetClanNameResponse EMsg = 4355 + EMsg_AMGrantCoupon EMsg = 4356 + EMsg_AMGrantCouponResponse EMsg = 4357 + EMsg_AMIsPackageRestrictedInUserCountry EMsg = 4358 + EMsg_AMIsPackageRestrictedInUserCountryResponse EMsg = 4359 + EMsg_AMHandlePendingTransactionResponse EMsg = 4360 + EMsg_AMGrantGuestPasses2 EMsg = 4361 + EMsg_AMGrantGuestPasses2Response EMsg = 4362 + EMsg_AMSessionQuery EMsg = 4363 + EMsg_AMSessionQueryResponse EMsg = 4364 + EMsg_AMGetPlayerBanDetails EMsg = 4365 + EMsg_AMGetPlayerBanDetailsResponse EMsg = 4366 + EMsg_AMFinalizePurchase EMsg = 4367 + EMsg_AMFinalizePurchaseResponse EMsg = 4368 + EMsg_AMPersonaChangeResponse EMsg = 4372 + EMsg_AMGetClanDetailsForForumCreation EMsg = 4373 + EMsg_AMGetClanDetailsForForumCreationResponse EMsg = 4374 + EMsg_AMGetPendingNotificationCount EMsg = 4375 + EMsg_AMGetPendingNotificationCountResponse EMsg = 4376 + EMsg_AMPasswordHashUpgrade EMsg = 4377 + EMsg_AMMoPayPayment EMsg = 4378 + EMsg_AMMoPayPaymentResponse EMsg = 4379 + EMsg_AMBoaCompraPayment EMsg = 4380 + EMsg_AMBoaCompraPaymentResponse EMsg = 4381 + EMsg_AMExpireCaptchaByGID EMsg = 4382 + EMsg_AMCompleteExternalPurchase EMsg = 4383 + EMsg_AMCompleteExternalPurchaseResponse EMsg = 4384 + EMsg_AMResolveNegativeWalletCredits EMsg = 4385 + EMsg_AMResolveNegativeWalletCreditsResponse EMsg = 4386 + EMsg_AMPayelpPayment EMsg = 4387 + EMsg_AMPayelpPaymentResponse EMsg = 4388 + EMsg_AMPlayerGetClanBasicDetails EMsg = 4389 + EMsg_AMPlayerGetClanBasicDetailsResponse EMsg = 4390 + EMsg_AMTwoFactorRecoverAuthenticatorRequest EMsg = 4402 + EMsg_AMTwoFactorRecoverAuthenticatorResponse EMsg = 4403 + EMsg_AMValidatePasswordResetCodeAndSendSmsRequest EMsg = 4406 + EMsg_AMValidatePasswordResetCodeAndSendSmsResponse EMsg = 4407 + EMsg_AMGetAccountResetDetailsRequest EMsg = 4408 + EMsg_AMGetAccountResetDetailsResponse EMsg = 4409 + EMsg_BasePSRange EMsg = 5000 + EMsg_PSCreateShoppingCart EMsg = 5001 + EMsg_PSCreateShoppingCartResponse EMsg = 5002 + EMsg_PSIsValidShoppingCart EMsg = 5003 + EMsg_PSIsValidShoppingCartResponse EMsg = 5004 + EMsg_PSAddPackageToShoppingCart EMsg = 5005 + EMsg_PSAddPackageToShoppingCartResponse EMsg = 5006 + EMsg_PSRemoveLineItemFromShoppingCart EMsg = 5007 + EMsg_PSRemoveLineItemFromShoppingCartResponse EMsg = 5008 + EMsg_PSGetShoppingCartContents EMsg = 5009 + EMsg_PSGetShoppingCartContentsResponse EMsg = 5010 + EMsg_PSAddWalletCreditToShoppingCart EMsg = 5011 + EMsg_PSAddWalletCreditToShoppingCartResponse EMsg = 5012 + EMsg_BaseUFSRange EMsg = 5200 + EMsg_ClientUFSUploadFileRequest EMsg = 5202 + EMsg_ClientUFSUploadFileResponse EMsg = 5203 + EMsg_ClientUFSUploadFileChunk EMsg = 5204 + EMsg_ClientUFSUploadFileFinished EMsg = 5205 + EMsg_ClientUFSGetFileListForApp EMsg = 5206 + EMsg_ClientUFSGetFileListForAppResponse EMsg = 5207 + EMsg_ClientUFSDownloadRequest EMsg = 5210 + EMsg_ClientUFSDownloadResponse EMsg = 5211 + EMsg_ClientUFSDownloadChunk EMsg = 5212 + EMsg_ClientUFSLoginRequest EMsg = 5213 + EMsg_ClientUFSLoginResponse EMsg = 5214 + EMsg_UFSReloadPartitionInfo EMsg = 5215 + EMsg_ClientUFSTransferHeartbeat EMsg = 5216 + EMsg_UFSSynchronizeFile EMsg = 5217 + EMsg_UFSSynchronizeFileResponse EMsg = 5218 + EMsg_ClientUFSDeleteFileRequest EMsg = 5219 + EMsg_ClientUFSDeleteFileResponse EMsg = 5220 + EMsg_UFSDownloadRequest EMsg = 5221 + EMsg_UFSDownloadResponse EMsg = 5222 + EMsg_UFSDownloadChunk EMsg = 5223 + EMsg_ClientUFSGetUGCDetails EMsg = 5226 + EMsg_ClientUFSGetUGCDetailsResponse EMsg = 5227 + EMsg_UFSUpdateFileFlags EMsg = 5228 + EMsg_UFSUpdateFileFlagsResponse EMsg = 5229 + EMsg_ClientUFSGetSingleFileInfo EMsg = 5230 + EMsg_ClientUFSGetSingleFileInfoResponse EMsg = 5231 + EMsg_ClientUFSShareFile EMsg = 5232 + EMsg_ClientUFSShareFileResponse EMsg = 5233 + EMsg_UFSReloadAccount EMsg = 5234 + EMsg_UFSReloadAccountResponse EMsg = 5235 + EMsg_UFSUpdateRecordBatched EMsg = 5236 + EMsg_UFSUpdateRecordBatchedResponse EMsg = 5237 + EMsg_UFSMigrateFile EMsg = 5238 + EMsg_UFSMigrateFileResponse EMsg = 5239 + EMsg_UFSGetUGCURLs EMsg = 5240 + EMsg_UFSGetUGCURLsResponse EMsg = 5241 + EMsg_UFSHttpUploadFileFinishRequest EMsg = 5242 + EMsg_UFSHttpUploadFileFinishResponse EMsg = 5243 + EMsg_UFSDownloadStartRequest EMsg = 5244 + EMsg_UFSDownloadStartResponse EMsg = 5245 + EMsg_UFSDownloadChunkRequest EMsg = 5246 + EMsg_UFSDownloadChunkResponse EMsg = 5247 + EMsg_UFSDownloadFinishRequest EMsg = 5248 + EMsg_UFSDownloadFinishResponse EMsg = 5249 + EMsg_UFSFlushURLCache EMsg = 5250 + EMsg_UFSUploadCommit EMsg = 5251 + EMsg_UFSUploadCommitResponse EMsg = 5252 + EMsg_BaseClient2 EMsg = 5400 + EMsg_ClientRequestForgottenPasswordEmail EMsg = 5401 + EMsg_ClientRequestForgottenPasswordEmailResponse EMsg = 5402 + EMsg_ClientCreateAccountResponse EMsg = 5403 + EMsg_ClientResetForgottenPassword EMsg = 5404 + EMsg_ClientResetForgottenPasswordResponse EMsg = 5405 + EMsg_ClientCreateAccount2 EMsg = 5406 + EMsg_ClientInformOfResetForgottenPassword EMsg = 5407 + EMsg_ClientInformOfResetForgottenPasswordResponse EMsg = 5408 + EMsg_ClientAnonUserLogOn_Deprecated EMsg = 5409 // Deprecated + EMsg_ClientGamesPlayedWithDataBlob EMsg = 5410 + EMsg_ClientUpdateUserGameInfo EMsg = 5411 + EMsg_ClientFileToDownload EMsg = 5412 + EMsg_ClientFileToDownloadResponse EMsg = 5413 + EMsg_ClientLBSSetScore EMsg = 5414 + EMsg_ClientLBSSetScoreResponse EMsg = 5415 + EMsg_ClientLBSFindOrCreateLB EMsg = 5416 + EMsg_ClientLBSFindOrCreateLBResponse EMsg = 5417 + EMsg_ClientLBSGetLBEntries EMsg = 5418 + EMsg_ClientLBSGetLBEntriesResponse EMsg = 5419 + EMsg_ClientMarketingMessageUpdate EMsg = 5420 // Deprecated + EMsg_ClientChatDeclined EMsg = 5426 + EMsg_ClientFriendMsgIncoming EMsg = 5427 + EMsg_ClientAuthList_Deprecated EMsg = 5428 // Deprecated + EMsg_ClientTicketAuthComplete EMsg = 5429 + EMsg_ClientIsLimitedAccount EMsg = 5430 + EMsg_ClientRequestAuthList EMsg = 5431 + EMsg_ClientAuthList EMsg = 5432 + EMsg_ClientStat EMsg = 5433 + EMsg_ClientP2PConnectionInfo EMsg = 5434 + EMsg_ClientP2PConnectionFailInfo EMsg = 5435 + EMsg_ClientGetNumberOfCurrentPlayers EMsg = 5436 + EMsg_ClientGetNumberOfCurrentPlayersResponse EMsg = 5437 + EMsg_ClientGetDepotDecryptionKey EMsg = 5438 + EMsg_ClientGetDepotDecryptionKeyResponse EMsg = 5439 + EMsg_GSPerformHardwareSurvey EMsg = 5440 + EMsg_ClientGetAppBetaPasswords EMsg = 5441 + EMsg_ClientGetAppBetaPasswordsResponse EMsg = 5442 + EMsg_ClientEnableTestLicense EMsg = 5443 + EMsg_ClientEnableTestLicenseResponse EMsg = 5444 + EMsg_ClientDisableTestLicense EMsg = 5445 + EMsg_ClientDisableTestLicenseResponse EMsg = 5446 + EMsg_ClientRequestValidationMail EMsg = 5448 + EMsg_ClientRequestValidationMailResponse EMsg = 5449 + EMsg_ClientCheckAppBetaPassword EMsg = 5450 + EMsg_ClientCheckAppBetaPasswordResponse EMsg = 5451 + EMsg_ClientToGC EMsg = 5452 + EMsg_ClientFromGC EMsg = 5453 + EMsg_ClientRequestChangeMail EMsg = 5454 + EMsg_ClientRequestChangeMailResponse EMsg = 5455 + EMsg_ClientEmailAddrInfo EMsg = 5456 + EMsg_ClientPasswordChange3 EMsg = 5457 + EMsg_ClientEmailChange3 EMsg = 5458 + EMsg_ClientPersonalQAChange3 EMsg = 5459 + EMsg_ClientResetForgottenPassword3 EMsg = 5460 + EMsg_ClientRequestForgottenPasswordEmail3 EMsg = 5461 + EMsg_ClientCreateAccount3 EMsg = 5462 // Deprecated + EMsg_ClientNewLoginKey EMsg = 5463 + EMsg_ClientNewLoginKeyAccepted EMsg = 5464 + EMsg_ClientLogOnWithHash_Deprecated EMsg = 5465 // Deprecated + EMsg_ClientStoreUserStats2 EMsg = 5466 + EMsg_ClientStatsUpdated EMsg = 5467 + EMsg_ClientActivateOEMLicense EMsg = 5468 + EMsg_ClientRegisterOEMMachine EMsg = 5469 + EMsg_ClientRegisterOEMMachineResponse EMsg = 5470 + EMsg_ClientRequestedClientStats EMsg = 5480 + EMsg_ClientStat2Int32 EMsg = 5481 + EMsg_ClientStat2 EMsg = 5482 + EMsg_ClientVerifyPassword EMsg = 5483 + EMsg_ClientVerifyPasswordResponse EMsg = 5484 + EMsg_ClientDRMDownloadRequest EMsg = 5485 + EMsg_ClientDRMDownloadResponse EMsg = 5486 + EMsg_ClientDRMFinalResult EMsg = 5487 + EMsg_ClientGetFriendsWhoPlayGame EMsg = 5488 + EMsg_ClientGetFriendsWhoPlayGameResponse EMsg = 5489 + EMsg_ClientOGSBeginSession EMsg = 5490 + EMsg_ClientOGSBeginSessionResponse EMsg = 5491 + EMsg_ClientOGSEndSession EMsg = 5492 + EMsg_ClientOGSEndSessionResponse EMsg = 5493 + EMsg_ClientOGSWriteRow EMsg = 5494 + EMsg_ClientDRMTest EMsg = 5495 + EMsg_ClientDRMTestResult EMsg = 5496 + EMsg_ClientServerUnavailable EMsg = 5500 + EMsg_ClientServersAvailable EMsg = 5501 + EMsg_ClientRegisterAuthTicketWithCM EMsg = 5502 + EMsg_ClientGCMsgFailed EMsg = 5503 + EMsg_ClientMicroTxnAuthRequest EMsg = 5504 + EMsg_ClientMicroTxnAuthorize EMsg = 5505 + EMsg_ClientMicroTxnAuthorizeResponse EMsg = 5506 + EMsg_ClientAppMinutesPlayedData EMsg = 5507 + EMsg_ClientGetMicroTxnInfo EMsg = 5508 + EMsg_ClientGetMicroTxnInfoResponse EMsg = 5509 + EMsg_ClientMarketingMessageUpdate2 EMsg = 5510 + EMsg_ClientDeregisterWithServer EMsg = 5511 + EMsg_ClientSubscribeToPersonaFeed EMsg = 5512 + EMsg_ClientLogon EMsg = 5514 + EMsg_ClientGetClientDetails EMsg = 5515 + EMsg_ClientGetClientDetailsResponse EMsg = 5516 + EMsg_ClientReportOverlayDetourFailure EMsg = 5517 + EMsg_ClientGetClientAppList EMsg = 5518 + EMsg_ClientGetClientAppListResponse EMsg = 5519 + EMsg_ClientInstallClientApp EMsg = 5520 + EMsg_ClientInstallClientAppResponse EMsg = 5521 + EMsg_ClientUninstallClientApp EMsg = 5522 + EMsg_ClientUninstallClientAppResponse EMsg = 5523 + EMsg_ClientSetClientAppUpdateState EMsg = 5524 + EMsg_ClientSetClientAppUpdateStateResponse EMsg = 5525 + EMsg_ClientRequestEncryptedAppTicket EMsg = 5526 + EMsg_ClientRequestEncryptedAppTicketResponse EMsg = 5527 + EMsg_ClientWalletInfoUpdate EMsg = 5528 + EMsg_ClientLBSSetUGC EMsg = 5529 + EMsg_ClientLBSSetUGCResponse EMsg = 5530 + EMsg_ClientAMGetClanOfficers EMsg = 5531 + EMsg_ClientAMGetClanOfficersResponse EMsg = 5532 + EMsg_ClientCheckFileSignature EMsg = 5533 + EMsg_ClientCheckFileSignatureResponse EMsg = 5534 + EMsg_ClientFriendProfileInfo EMsg = 5535 + EMsg_ClientFriendProfileInfoResponse EMsg = 5536 + EMsg_ClientUpdateMachineAuth EMsg = 5537 + EMsg_ClientUpdateMachineAuthResponse EMsg = 5538 + EMsg_ClientReadMachineAuth EMsg = 5539 + EMsg_ClientReadMachineAuthResponse EMsg = 5540 + EMsg_ClientRequestMachineAuth EMsg = 5541 + EMsg_ClientRequestMachineAuthResponse EMsg = 5542 + EMsg_ClientScreenshotsChanged EMsg = 5543 + EMsg_ClientEmailChange4 EMsg = 5544 + EMsg_ClientEmailChangeResponse4 EMsg = 5545 + EMsg_ClientGetCDNAuthToken EMsg = 5546 + EMsg_ClientGetCDNAuthTokenResponse EMsg = 5547 + EMsg_ClientDownloadRateStatistics EMsg = 5548 + EMsg_ClientRequestAccountData EMsg = 5549 + EMsg_ClientRequestAccountDataResponse EMsg = 5550 + EMsg_ClientResetForgottenPassword4 EMsg = 5551 + EMsg_ClientHideFriend EMsg = 5552 + EMsg_ClientFriendsGroupsList EMsg = 5553 + EMsg_ClientGetClanActivityCounts EMsg = 5554 + EMsg_ClientGetClanActivityCountsResponse EMsg = 5555 + EMsg_ClientOGSReportString EMsg = 5556 + EMsg_ClientOGSReportBug EMsg = 5557 + EMsg_ClientSentLogs EMsg = 5558 + EMsg_ClientLogonGameServer EMsg = 5559 + EMsg_AMClientCreateFriendsGroup EMsg = 5560 + EMsg_AMClientCreateFriendsGroupResponse EMsg = 5561 + EMsg_AMClientDeleteFriendsGroup EMsg = 5562 + EMsg_AMClientDeleteFriendsGroupResponse EMsg = 5563 + EMsg_AMClientRenameFriendsGroup EMsg = 5564 + EMsg_AMClientRenameFriendsGroupResponse EMsg = 5565 + EMsg_AMClientAddFriendToGroup EMsg = 5566 + EMsg_AMClientAddFriendToGroupResponse EMsg = 5567 + EMsg_AMClientRemoveFriendFromGroup EMsg = 5568 + EMsg_AMClientRemoveFriendFromGroupResponse EMsg = 5569 + EMsg_ClientAMGetPersonaNameHistory EMsg = 5570 + EMsg_ClientAMGetPersonaNameHistoryResponse EMsg = 5571 + EMsg_ClientRequestFreeLicense EMsg = 5572 + EMsg_ClientRequestFreeLicenseResponse EMsg = 5573 + EMsg_ClientDRMDownloadRequestWithCrashData EMsg = 5574 + EMsg_ClientAuthListAck EMsg = 5575 + EMsg_ClientItemAnnouncements EMsg = 5576 + EMsg_ClientRequestItemAnnouncements EMsg = 5577 + EMsg_ClientFriendMsgEchoToSender EMsg = 5578 + EMsg_ClientChangeSteamGuardOptions EMsg = 5579 // Deprecated + EMsg_ClientChangeSteamGuardOptionsResponse EMsg = 5580 // Deprecated + EMsg_ClientOGSGameServerPingSample EMsg = 5581 + EMsg_ClientCommentNotifications EMsg = 5582 + EMsg_ClientRequestCommentNotifications EMsg = 5583 + EMsg_ClientPersonaChangeResponse EMsg = 5584 + EMsg_ClientRequestWebAPIAuthenticateUserNonce EMsg = 5585 + EMsg_ClientRequestWebAPIAuthenticateUserNonceResponse EMsg = 5586 + EMsg_ClientPlayerNicknameList EMsg = 5587 + EMsg_AMClientSetPlayerNickname EMsg = 5588 + EMsg_AMClientSetPlayerNicknameResponse EMsg = 5589 + EMsg_ClientRequestOAuthTokenForApp EMsg = 5590 // Deprecated + EMsg_ClientRequestOAuthTokenForAppResponse EMsg = 5591 // Deprecated + EMsg_ClientCreateAccountProto EMsg = 5590 + EMsg_ClientCreateAccountProtoResponse EMsg = 5591 + EMsg_ClientGetNumberOfCurrentPlayersDP EMsg = 5592 + EMsg_ClientGetNumberOfCurrentPlayersDPResponse EMsg = 5593 + EMsg_ClientServiceMethod EMsg = 5594 + EMsg_ClientServiceMethodResponse EMsg = 5595 + EMsg_ClientFriendUserStatusPublished EMsg = 5596 + EMsg_ClientCurrentUIMode EMsg = 5597 + EMsg_ClientVanityURLChangedNotification EMsg = 5598 + EMsg_ClientUserNotifications EMsg = 5599 + EMsg_BaseDFS EMsg = 5600 + EMsg_DFSGetFile EMsg = 5601 + EMsg_DFSInstallLocalFile EMsg = 5602 + EMsg_DFSConnection EMsg = 5603 + EMsg_DFSConnectionReply EMsg = 5604 + EMsg_ClientDFSAuthenticateRequest EMsg = 5605 + EMsg_ClientDFSAuthenticateResponse EMsg = 5606 + EMsg_ClientDFSEndSession EMsg = 5607 + EMsg_DFSPurgeFile EMsg = 5608 + EMsg_DFSRouteFile EMsg = 5609 + EMsg_DFSGetFileFromServer EMsg = 5610 + EMsg_DFSAcceptedResponse EMsg = 5611 + EMsg_DFSRequestPingback EMsg = 5612 + EMsg_DFSRecvTransmitFile EMsg = 5613 + EMsg_DFSSendTransmitFile EMsg = 5614 + EMsg_DFSRequestPingback2 EMsg = 5615 + EMsg_DFSResponsePingback2 EMsg = 5616 + EMsg_ClientDFSDownloadStatus EMsg = 5617 + EMsg_DFSStartTransfer EMsg = 5618 + EMsg_DFSTransferComplete EMsg = 5619 + EMsg_BaseMDS EMsg = 5800 + EMsg_ClientMDSLoginRequest EMsg = 5801 // Deprecated + EMsg_ClientMDSLoginResponse EMsg = 5802 // Deprecated + EMsg_ClientMDSUploadManifestRequest EMsg = 5803 // Deprecated + EMsg_ClientMDSUploadManifestResponse EMsg = 5804 // Deprecated + EMsg_ClientMDSTransmitManifestDataChunk EMsg = 5805 // Deprecated + EMsg_ClientMDSHeartbeat EMsg = 5806 // Deprecated + EMsg_ClientMDSUploadDepotChunks EMsg = 5807 // Deprecated + EMsg_ClientMDSUploadDepotChunksResponse EMsg = 5808 // Deprecated + EMsg_ClientMDSInitDepotBuildRequest EMsg = 5809 // Deprecated + EMsg_ClientMDSInitDepotBuildResponse EMsg = 5810 // Deprecated + EMsg_AMToMDSGetDepotDecryptionKey EMsg = 5812 + EMsg_MDSToAMGetDepotDecryptionKeyResponse EMsg = 5813 + EMsg_MDSGetVersionsForDepot EMsg = 5814 + EMsg_MDSGetVersionsForDepotResponse EMsg = 5815 + EMsg_MDSSetPublicVersionForDepot EMsg = 5816 // Deprecated + EMsg_MDSSetPublicVersionForDepotResponse EMsg = 5817 // Deprecated + EMsg_ClientMDSInitWorkshopBuildRequest EMsg = 5816 // Deprecated + EMsg_ClientMDSInitWorkshopBuildResponse EMsg = 5817 // Deprecated + EMsg_ClientMDSGetDepotManifest EMsg = 5818 // Deprecated + EMsg_ClientMDSGetDepotManifestResponse EMsg = 5819 // Deprecated + EMsg_ClientMDSGetDepotManifestChunk EMsg = 5820 // Deprecated + EMsg_ClientMDSUploadRateTest EMsg = 5823 // Deprecated + EMsg_ClientMDSUploadRateTestResponse EMsg = 5824 // Deprecated + EMsg_MDSDownloadDepotChunksAck EMsg = 5825 + EMsg_MDSContentServerStatsBroadcast EMsg = 5826 + EMsg_MDSContentServerConfigRequest EMsg = 5827 + EMsg_MDSContentServerConfig EMsg = 5828 + EMsg_MDSGetDepotManifest EMsg = 5829 + EMsg_MDSGetDepotManifestResponse EMsg = 5830 + EMsg_MDSGetDepotManifestChunk EMsg = 5831 + EMsg_MDSGetDepotChunk EMsg = 5832 + EMsg_MDSGetDepotChunkResponse EMsg = 5833 + EMsg_MDSGetDepotChunkChunk EMsg = 5834 + EMsg_MDSUpdateContentServerConfig EMsg = 5835 + EMsg_MDSGetServerListForUser EMsg = 5836 + EMsg_MDSGetServerListForUserResponse EMsg = 5837 + EMsg_ClientMDSRegisterAppBuild EMsg = 5838 // Deprecated + EMsg_ClientMDSRegisterAppBuildResponse EMsg = 5839 // Deprecated + EMsg_ClientMDSSetAppBuildLive EMsg = 5840 + EMsg_ClientMDSSetAppBuildLiveResponse EMsg = 5841 + EMsg_ClientMDSGetPrevDepotBuild EMsg = 5842 + EMsg_ClientMDSGetPrevDepotBuildResponse EMsg = 5843 + EMsg_MDSToCSFlushChunk EMsg = 5844 + EMsg_ClientMDSSignInstallScript EMsg = 5845 // Deprecated + EMsg_ClientMDSSignInstallScriptResponse EMsg = 5846 // Deprecated + EMsg_CSBase EMsg = 6200 + EMsg_CSPing EMsg = 6201 + EMsg_CSPingResponse EMsg = 6202 + EMsg_GMSBase EMsg = 6400 + EMsg_GMSGameServerReplicate EMsg = 6401 + EMsg_ClientGMSServerQuery EMsg = 6403 + EMsg_GMSClientServerQueryResponse EMsg = 6404 + EMsg_AMGMSGameServerUpdate EMsg = 6405 + EMsg_AMGMSGameServerRemove EMsg = 6406 + EMsg_GameServerOutOfDate EMsg = 6407 + EMsg_ClientAuthorizeLocalDeviceRequest EMsg = 6501 + EMsg_ClientAuthorizeLocalDevice EMsg = 6502 + EMsg_ClientDeauthorizeDeviceRequest EMsg = 6503 + EMsg_ClientDeauthorizeDevice EMsg = 6504 + EMsg_ClientUseLocalDeviceAuthorizations EMsg = 6505 + EMsg_ClientGetAuthorizedDevices EMsg = 6506 + EMsg_ClientGetAuthorizedDevicesResponse EMsg = 6507 + EMsg_MMSBase EMsg = 6600 + EMsg_ClientMMSCreateLobby EMsg = 6601 + EMsg_ClientMMSCreateLobbyResponse EMsg = 6602 + EMsg_ClientMMSJoinLobby EMsg = 6603 + EMsg_ClientMMSJoinLobbyResponse EMsg = 6604 + EMsg_ClientMMSLeaveLobby EMsg = 6605 + EMsg_ClientMMSLeaveLobbyResponse EMsg = 6606 + EMsg_ClientMMSGetLobbyList EMsg = 6607 + EMsg_ClientMMSGetLobbyListResponse EMsg = 6608 + EMsg_ClientMMSSetLobbyData EMsg = 6609 + EMsg_ClientMMSSetLobbyDataResponse EMsg = 6610 + EMsg_ClientMMSGetLobbyData EMsg = 6611 + EMsg_ClientMMSLobbyData EMsg = 6612 + EMsg_ClientMMSSendLobbyChatMsg EMsg = 6613 + EMsg_ClientMMSLobbyChatMsg EMsg = 6614 + EMsg_ClientMMSSetLobbyOwner EMsg = 6615 + EMsg_ClientMMSSetLobbyOwnerResponse EMsg = 6616 + EMsg_ClientMMSSetLobbyGameServer EMsg = 6617 + EMsg_ClientMMSLobbyGameServerSet EMsg = 6618 + EMsg_ClientMMSUserJoinedLobby EMsg = 6619 + EMsg_ClientMMSUserLeftLobby EMsg = 6620 + EMsg_ClientMMSInviteToLobby EMsg = 6621 + EMsg_ClientMMSFlushFrenemyListCache EMsg = 6622 + EMsg_ClientMMSFlushFrenemyListCacheResponse EMsg = 6623 + EMsg_ClientMMSSetLobbyLinked EMsg = 6624 + EMsg_NonStdMsgBase EMsg = 6800 + EMsg_NonStdMsgMemcached EMsg = 6801 + EMsg_NonStdMsgHTTPServer EMsg = 6802 + EMsg_NonStdMsgHTTPClient EMsg = 6803 + EMsg_NonStdMsgWGResponse EMsg = 6804 + EMsg_NonStdMsgPHPSimulator EMsg = 6805 + EMsg_NonStdMsgChase EMsg = 6806 + EMsg_NonStdMsgDFSTransfer EMsg = 6807 + EMsg_NonStdMsgTests EMsg = 6808 + EMsg_NonStdMsgUMQpipeAAPL EMsg = 6809 + EMsg_NonStdMsgSyslog EMsg = 6810 + EMsg_NonStdMsgLogsink EMsg = 6811 + EMsg_UDSBase EMsg = 7000 + EMsg_ClientUDSP2PSessionStarted EMsg = 7001 + EMsg_ClientUDSP2PSessionEnded EMsg = 7002 + EMsg_UDSRenderUserAuth EMsg = 7003 + EMsg_UDSRenderUserAuthResponse EMsg = 7004 + EMsg_ClientUDSInviteToGame EMsg = 7005 + EMsg_UDSFindSession EMsg = 7006 + EMsg_UDSFindSessionResponse EMsg = 7007 + EMsg_MPASBase EMsg = 7100 + EMsg_MPASVacBanReset EMsg = 7101 + EMsg_KGSBase EMsg = 7200 + EMsg_KGSAllocateKeyRange EMsg = 7201 + EMsg_KGSAllocateKeyRangeResponse EMsg = 7202 + EMsg_KGSGenerateKeys EMsg = 7203 + EMsg_KGSGenerateKeysResponse EMsg = 7204 + EMsg_KGSRemapKeys EMsg = 7205 + EMsg_KGSRemapKeysResponse EMsg = 7206 + EMsg_KGSGenerateGameStopWCKeys EMsg = 7207 + EMsg_KGSGenerateGameStopWCKeysResponse EMsg = 7208 + EMsg_UCMBase EMsg = 7300 + EMsg_ClientUCMAddScreenshot EMsg = 7301 + EMsg_ClientUCMAddScreenshotResponse EMsg = 7302 + EMsg_UCMValidateObjectExists EMsg = 7303 + EMsg_UCMValidateObjectExistsResponse EMsg = 7304 + EMsg_UCMResetCommunityContent EMsg = 7307 + EMsg_UCMResetCommunityContentResponse EMsg = 7308 + EMsg_ClientUCMDeleteScreenshot EMsg = 7309 + EMsg_ClientUCMDeleteScreenshotResponse EMsg = 7310 + EMsg_ClientUCMPublishFile EMsg = 7311 + EMsg_ClientUCMPublishFileResponse EMsg = 7312 + EMsg_ClientUCMGetPublishedFileDetails EMsg = 7313 // Deprecated + EMsg_ClientUCMGetPublishedFileDetailsResponse EMsg = 7314 // Deprecated + EMsg_ClientUCMDeletePublishedFile EMsg = 7315 + EMsg_ClientUCMDeletePublishedFileResponse EMsg = 7316 + EMsg_ClientUCMEnumerateUserPublishedFiles EMsg = 7317 + EMsg_ClientUCMEnumerateUserPublishedFilesResponse EMsg = 7318 + EMsg_ClientUCMSubscribePublishedFile EMsg = 7319 // Deprecated + EMsg_ClientUCMSubscribePublishedFileResponse EMsg = 7320 // Deprecated + EMsg_ClientUCMEnumerateUserSubscribedFiles EMsg = 7321 + EMsg_ClientUCMEnumerateUserSubscribedFilesResponse EMsg = 7322 + EMsg_ClientUCMUnsubscribePublishedFile EMsg = 7323 // Deprecated + EMsg_ClientUCMUnsubscribePublishedFileResponse EMsg = 7324 // Deprecated + EMsg_ClientUCMUpdatePublishedFile EMsg = 7325 + EMsg_ClientUCMUpdatePublishedFileResponse EMsg = 7326 + EMsg_UCMUpdatePublishedFile EMsg = 7327 + EMsg_UCMUpdatePublishedFileResponse EMsg = 7328 + EMsg_UCMDeletePublishedFile EMsg = 7329 + EMsg_UCMDeletePublishedFileResponse EMsg = 7330 + EMsg_UCMUpdatePublishedFileStat EMsg = 7331 + EMsg_UCMUpdatePublishedFileBan EMsg = 7332 + EMsg_UCMUpdatePublishedFileBanResponse EMsg = 7333 + EMsg_UCMUpdateTaggedScreenshot EMsg = 7334 + EMsg_UCMAddTaggedScreenshot EMsg = 7335 + EMsg_UCMRemoveTaggedScreenshot EMsg = 7336 + EMsg_UCMReloadPublishedFile EMsg = 7337 + EMsg_UCMReloadUserFileListCaches EMsg = 7338 + EMsg_UCMPublishedFileReported EMsg = 7339 + EMsg_UCMUpdatePublishedFileIncompatibleStatus EMsg = 7340 + EMsg_UCMPublishedFilePreviewAdd EMsg = 7341 + EMsg_UCMPublishedFilePreviewAddResponse EMsg = 7342 + EMsg_UCMPublishedFilePreviewRemove EMsg = 7343 + EMsg_UCMPublishedFilePreviewRemoveResponse EMsg = 7344 + EMsg_UCMPublishedFilePreviewChangeSortOrder EMsg = 7345 + EMsg_UCMPublishedFilePreviewChangeSortOrderResponse EMsg = 7346 + EMsg_ClientUCMPublishedFileSubscribed EMsg = 7347 + EMsg_ClientUCMPublishedFileUnsubscribed EMsg = 7348 + EMsg_UCMPublishedFileSubscribed EMsg = 7349 + EMsg_UCMPublishedFileUnsubscribed EMsg = 7350 + EMsg_UCMPublishFile EMsg = 7351 + EMsg_UCMPublishFileResponse EMsg = 7352 + EMsg_UCMPublishedFileChildAdd EMsg = 7353 + EMsg_UCMPublishedFileChildAddResponse EMsg = 7354 + EMsg_UCMPublishedFileChildRemove EMsg = 7355 + EMsg_UCMPublishedFileChildRemoveResponse EMsg = 7356 + EMsg_UCMPublishedFileChildChangeSortOrder EMsg = 7357 + EMsg_UCMPublishedFileChildChangeSortOrderResponse EMsg = 7358 + EMsg_UCMPublishedFileParentChanged EMsg = 7359 + EMsg_ClientUCMGetPublishedFilesForUser EMsg = 7360 + EMsg_ClientUCMGetPublishedFilesForUserResponse EMsg = 7361 + EMsg_UCMGetPublishedFilesForUser EMsg = 7362 + EMsg_UCMGetPublishedFilesForUserResponse EMsg = 7363 + EMsg_ClientUCMSetUserPublishedFileAction EMsg = 7364 + EMsg_ClientUCMSetUserPublishedFileActionResponse EMsg = 7365 + EMsg_ClientUCMEnumeratePublishedFilesByUserAction EMsg = 7366 + EMsg_ClientUCMEnumeratePublishedFilesByUserActionResponse EMsg = 7367 + EMsg_ClientUCMPublishedFileDeleted EMsg = 7368 + EMsg_UCMGetUserSubscribedFiles EMsg = 7369 + EMsg_UCMGetUserSubscribedFilesResponse EMsg = 7370 + EMsg_UCMFixStatsPublishedFile EMsg = 7371 + EMsg_UCMDeleteOldScreenshot EMsg = 7372 + EMsg_UCMDeleteOldScreenshotResponse EMsg = 7373 + EMsg_UCMDeleteOldVideo EMsg = 7374 + EMsg_UCMDeleteOldVideoResponse EMsg = 7375 + EMsg_UCMUpdateOldScreenshotPrivacy EMsg = 7376 + EMsg_UCMUpdateOldScreenshotPrivacyResponse EMsg = 7377 + EMsg_ClientUCMEnumerateUserSubscribedFilesWithUpdates EMsg = 7378 + EMsg_ClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse EMsg = 7379 + EMsg_UCMPublishedFileContentUpdated EMsg = 7380 + EMsg_UCMPublishedFileUpdated EMsg = 7381 + EMsg_ClientWorkshopItemChangesRequest EMsg = 7382 + EMsg_ClientWorkshopItemChangesResponse EMsg = 7383 + EMsg_ClientWorkshopItemInfoRequest EMsg = 7384 + EMsg_ClientWorkshopItemInfoResponse EMsg = 7385 + EMsg_FSBase EMsg = 7500 + EMsg_ClientRichPresenceUpload EMsg = 7501 + EMsg_ClientRichPresenceRequest EMsg = 7502 + EMsg_ClientRichPresenceInfo EMsg = 7503 + EMsg_FSRichPresenceRequest EMsg = 7504 + EMsg_FSRichPresenceResponse EMsg = 7505 + EMsg_FSComputeFrenematrix EMsg = 7506 + EMsg_FSComputeFrenematrixResponse EMsg = 7507 + EMsg_FSPlayStatusNotification EMsg = 7508 + EMsg_FSPublishPersonaStatus EMsg = 7509 + EMsg_FSAddOrRemoveFollower EMsg = 7510 + EMsg_FSAddOrRemoveFollowerResponse EMsg = 7511 + EMsg_FSUpdateFollowingList EMsg = 7512 + EMsg_FSCommentNotification EMsg = 7513 + EMsg_FSCommentNotificationViewed EMsg = 7514 + EMsg_ClientFSGetFollowerCount EMsg = 7515 + EMsg_ClientFSGetFollowerCountResponse EMsg = 7516 + EMsg_ClientFSGetIsFollowing EMsg = 7517 + EMsg_ClientFSGetIsFollowingResponse EMsg = 7518 + EMsg_ClientFSEnumerateFollowingList EMsg = 7519 + EMsg_ClientFSEnumerateFollowingListResponse EMsg = 7520 + EMsg_FSGetPendingNotificationCount EMsg = 7521 + EMsg_FSGetPendingNotificationCountResponse EMsg = 7522 + EMsg_ClientFSOfflineMessageNotification EMsg = 7523 + EMsg_ClientFSRequestOfflineMessageCount EMsg = 7524 + EMsg_ClientFSGetFriendMessageHistory EMsg = 7525 + EMsg_ClientFSGetFriendMessageHistoryResponse EMsg = 7526 + EMsg_ClientFSGetFriendMessageHistoryForOfflineMessages EMsg = 7527 + EMsg_ClientFSGetFriendsSteamLevels EMsg = 7528 + EMsg_ClientFSGetFriendsSteamLevelsResponse EMsg = 7529 + EMsg_DRMRange2 EMsg = 7600 + EMsg_CEGVersionSetEnableDisableRequest EMsg = 7600 + EMsg_CEGVersionSetEnableDisableResponse EMsg = 7601 + EMsg_CEGPropStatusDRMSRequest EMsg = 7602 + EMsg_CEGPropStatusDRMSResponse EMsg = 7603 + EMsg_CEGWhackFailureReportRequest EMsg = 7604 + EMsg_CEGWhackFailureReportResponse EMsg = 7605 + EMsg_DRMSFetchVersionSet EMsg = 7606 + EMsg_DRMSFetchVersionSetResponse EMsg = 7607 + EMsg_EconBase EMsg = 7700 + EMsg_EconTrading_InitiateTradeRequest EMsg = 7701 + EMsg_EconTrading_InitiateTradeProposed EMsg = 7702 + EMsg_EconTrading_InitiateTradeResponse EMsg = 7703 + EMsg_EconTrading_InitiateTradeResult EMsg = 7704 + EMsg_EconTrading_StartSession EMsg = 7705 + EMsg_EconTrading_CancelTradeRequest EMsg = 7706 + EMsg_EconFlushInventoryCache EMsg = 7707 + EMsg_EconFlushInventoryCacheResponse EMsg = 7708 + EMsg_EconCDKeyProcessTransaction EMsg = 7711 + EMsg_EconCDKeyProcessTransactionResponse EMsg = 7712 + EMsg_EconGetErrorLogs EMsg = 7713 + EMsg_EconGetErrorLogsResponse EMsg = 7714 + EMsg_RMRange EMsg = 7800 + EMsg_RMTestVerisignOTP EMsg = 7800 + EMsg_RMTestVerisignOTPResponse EMsg = 7801 + EMsg_RMDeleteMemcachedKeys EMsg = 7803 + EMsg_RMRemoteInvoke EMsg = 7804 + EMsg_BadLoginIPList EMsg = 7805 + EMsg_UGSBase EMsg = 7900 + EMsg_UGSUpdateGlobalStats EMsg = 7900 + EMsg_ClientUGSGetGlobalStats EMsg = 7901 + EMsg_ClientUGSGetGlobalStatsResponse EMsg = 7902 + EMsg_StoreBase EMsg = 8000 + EMsg_StoreUpdateRecommendationCount EMsg = 8000 + EMsg_UMQBase EMsg = 8100 + EMsg_UMQLogonRequest EMsg = 8100 + EMsg_UMQLogonResponse EMsg = 8101 + EMsg_UMQLogoffRequest EMsg = 8102 + EMsg_UMQLogoffResponse EMsg = 8103 + EMsg_UMQSendChatMessage EMsg = 8104 + EMsg_UMQIncomingChatMessage EMsg = 8105 + EMsg_UMQPoll EMsg = 8106 + EMsg_UMQPollResults EMsg = 8107 + EMsg_UMQ2AM_ClientMsgBatch EMsg = 8108 + EMsg_UMQEnqueueMobileSalePromotions EMsg = 8109 + EMsg_UMQEnqueueMobileAnnouncements EMsg = 8110 + EMsg_WorkshopBase EMsg = 8200 + EMsg_WorkshopAcceptTOSRequest EMsg = 8200 + EMsg_WorkshopAcceptTOSResponse EMsg = 8201 + EMsg_WebAPIBase EMsg = 8300 + EMsg_WebAPIValidateOAuth2Token EMsg = 8300 + EMsg_WebAPIValidateOAuth2TokenResponse EMsg = 8301 + EMsg_WebAPIInvalidateTokensForAccount EMsg = 8302 + EMsg_WebAPIRegisterGCInterfaces EMsg = 8303 + EMsg_WebAPIInvalidateOAuthClientCache EMsg = 8304 + EMsg_WebAPIInvalidateOAuthTokenCache EMsg = 8305 + EMsg_BackpackBase EMsg = 8400 + EMsg_BackpackAddToCurrency EMsg = 8401 + EMsg_BackpackAddToCurrencyResponse EMsg = 8402 + EMsg_CREBase EMsg = 8500 + EMsg_CRERankByTrend EMsg = 8501 // Deprecated + EMsg_CRERankByTrendResponse EMsg = 8502 // Deprecated + EMsg_CREItemVoteSummary EMsg = 8503 + EMsg_CREItemVoteSummaryResponse EMsg = 8504 + EMsg_CRERankByVote EMsg = 8505 // Deprecated + EMsg_CRERankByVoteResponse EMsg = 8506 // Deprecated + EMsg_CREUpdateUserPublishedItemVote EMsg = 8507 + EMsg_CREUpdateUserPublishedItemVoteResponse EMsg = 8508 + EMsg_CREGetUserPublishedItemVoteDetails EMsg = 8509 + EMsg_CREGetUserPublishedItemVoteDetailsResponse EMsg = 8510 + EMsg_CREEnumeratePublishedFiles EMsg = 8511 + EMsg_CREEnumeratePublishedFilesResponse EMsg = 8512 + EMsg_CREPublishedFileVoteAdded EMsg = 8513 + EMsg_SecretsBase EMsg = 8600 + EMsg_SecretsRequestCredentialPair EMsg = 8600 + EMsg_SecretsCredentialPairResponse EMsg = 8601 + EMsg_SecretsRequestServerIdentity EMsg = 8602 + EMsg_SecretsServerIdentityResponse EMsg = 8603 + EMsg_SecretsUpdateServerIdentities EMsg = 8604 + EMsg_BoxMonitorBase EMsg = 8700 + EMsg_BoxMonitorReportRequest EMsg = 8700 + EMsg_BoxMonitorReportResponse EMsg = 8701 + EMsg_LogsinkBase EMsg = 8800 + EMsg_LogsinkWriteReport EMsg = 8800 + EMsg_PICSBase EMsg = 8900 + EMsg_ClientPICSChangesSinceRequest EMsg = 8901 + EMsg_ClientPICSChangesSinceResponse EMsg = 8902 + EMsg_ClientPICSProductInfoRequest EMsg = 8903 + EMsg_ClientPICSProductInfoResponse EMsg = 8904 + EMsg_ClientPICSAccessTokenRequest EMsg = 8905 + EMsg_ClientPICSAccessTokenResponse EMsg = 8906 + EMsg_WorkerProcess EMsg = 9000 + EMsg_WorkerProcessPingRequest EMsg = 9000 + EMsg_WorkerProcessPingResponse EMsg = 9001 + EMsg_WorkerProcessShutdown EMsg = 9002 + EMsg_DRMWorkerProcess EMsg = 9100 + EMsg_DRMWorkerProcessDRMAndSign EMsg = 9100 + EMsg_DRMWorkerProcessDRMAndSignResponse EMsg = 9101 + EMsg_DRMWorkerProcessSteamworksInfoRequest EMsg = 9102 + EMsg_DRMWorkerProcessSteamworksInfoResponse EMsg = 9103 + EMsg_DRMWorkerProcessInstallDRMDLLRequest EMsg = 9104 + EMsg_DRMWorkerProcessInstallDRMDLLResponse EMsg = 9105 + EMsg_DRMWorkerProcessSecretIdStringRequest EMsg = 9106 + EMsg_DRMWorkerProcessSecretIdStringResponse EMsg = 9107 + EMsg_DRMWorkerProcessGetDRMGuidsFromFileRequest EMsg = 9108 + EMsg_DRMWorkerProcessGetDRMGuidsFromFileResponse EMsg = 9109 + EMsg_DRMWorkerProcessInstallProcessedFilesRequest EMsg = 9110 + EMsg_DRMWorkerProcessInstallProcessedFilesResponse EMsg = 9111 + EMsg_DRMWorkerProcessExamineBlobRequest EMsg = 9112 + EMsg_DRMWorkerProcessExamineBlobResponse EMsg = 9113 + EMsg_DRMWorkerProcessDescribeSecretRequest EMsg = 9114 + EMsg_DRMWorkerProcessDescribeSecretResponse EMsg = 9115 + EMsg_DRMWorkerProcessBackfillOriginalRequest EMsg = 9116 + EMsg_DRMWorkerProcessBackfillOriginalResponse EMsg = 9117 + EMsg_DRMWorkerProcessValidateDRMDLLRequest EMsg = 9118 + EMsg_DRMWorkerProcessValidateDRMDLLResponse EMsg = 9119 + EMsg_DRMWorkerProcessValidateFileRequest EMsg = 9120 + EMsg_DRMWorkerProcessValidateFileResponse EMsg = 9121 + EMsg_DRMWorkerProcessSplitAndInstallRequest EMsg = 9122 + EMsg_DRMWorkerProcessSplitAndInstallResponse EMsg = 9123 + EMsg_DRMWorkerProcessGetBlobRequest EMsg = 9124 + EMsg_DRMWorkerProcessGetBlobResponse EMsg = 9125 + EMsg_DRMWorkerProcessEvaluateCrashRequest EMsg = 9126 + EMsg_DRMWorkerProcessEvaluateCrashResponse EMsg = 9127 + EMsg_DRMWorkerProcessAnalyzeFileRequest EMsg = 9128 + EMsg_DRMWorkerProcessAnalyzeFileResponse EMsg = 9129 + EMsg_DRMWorkerProcessUnpackBlobRequest EMsg = 9130 + EMsg_DRMWorkerProcessUnpackBlobResponse EMsg = 9131 + EMsg_DRMWorkerProcessInstallAllRequest EMsg = 9132 + EMsg_DRMWorkerProcessInstallAllResponse EMsg = 9133 + EMsg_TestWorkerProcess EMsg = 9200 + EMsg_TestWorkerProcessLoadUnloadModuleRequest EMsg = 9200 + EMsg_TestWorkerProcessLoadUnloadModuleResponse EMsg = 9201 + EMsg_TestWorkerProcessServiceModuleCallRequest EMsg = 9202 + EMsg_TestWorkerProcessServiceModuleCallResponse EMsg = 9203 + EMsg_ClientGetEmoticonList EMsg = 9330 + EMsg_ClientEmoticonList EMsg = 9331 + EMsg_ClientSharedLibraryBase EMsg = 9400 + EMsg_ClientSharedLicensesLockStatus EMsg = 9403 // Deprecated + EMsg_ClientSharedLicensesStopPlaying EMsg = 9404 // Deprecated + EMsg_ClientSharedLibraryLockStatus EMsg = 9405 + EMsg_ClientSharedLibraryStopPlaying EMsg = 9406 + EMsg_ClientUnlockStreaming EMsg = 9507 + EMsg_ClientUnlockStreamingResponse EMsg = 9508 + EMsg_ClientPlayingSessionState EMsg = 9600 + EMsg_ClientKickPlayingSession EMsg = 9601 + EMsg_ClientBroadcastInit EMsg = 9700 + EMsg_ClientBroadcastFrames EMsg = 9701 + EMsg_ClientBroadcastDisconnect EMsg = 9702 + EMsg_ClientBroadcastScreenshot EMsg = 9703 + EMsg_ClientBroadcastUploadConfig EMsg = 9704 + EMsg_ClientVoiceCallPreAuthorize EMsg = 9800 + EMsg_ClientVoiceCallPreAuthorizeResponse EMsg = 9801 +) + +var EMsg_name = map[EMsg]string{ + 0: "EMsg_Invalid", + 1: "EMsg_Multi", + 100: "EMsg_BaseGeneral", + 113: "EMsg_DestJobFailed", + 115: "EMsg_Alert", + 120: "EMsg_SCIDRequest", + 121: "EMsg_SCIDResponse", + 123: "EMsg_JobHeartbeat", + 124: "EMsg_HubConnect", + 126: "EMsg_Subscribe", + 127: "EMsg_RouteMessage", + 128: "EMsg_RemoteSysID", + 129: "EMsg_AMCreateAccountResponse", + 130: "EMsg_WGRequest", + 131: "EMsg_WGResponse", + 132: "EMsg_KeepAlive", + 133: "EMsg_WebAPIJobRequest", + 134: "EMsg_WebAPIJobResponse", + 135: "EMsg_ClientSessionStart", + 136: "EMsg_ClientSessionEnd", + 137: "EMsg_ClientSessionUpdateAuthTicket", + 138: "EMsg_StatsDeprecated", + 139: "EMsg_Ping", + 140: "EMsg_PingResponse", + 141: "EMsg_Stats", + 142: "EMsg_RequestFullStatsBlock", + 143: "EMsg_LoadDBOCacheItem", + 144: "EMsg_LoadDBOCacheItemResponse", + 145: "EMsg_InvalidateDBOCacheItems", + 146: "EMsg_ServiceMethod", + 147: "EMsg_ServiceMethodResponse", + 200: "EMsg_BaseShell", + 201: "EMsg_Exit", + 202: "EMsg_DirRequest", + 203: "EMsg_DirResponse", + 204: "EMsg_ZipRequest", + 205: "EMsg_ZipResponse", + 215: "EMsg_UpdateRecordResponse", + 221: "EMsg_UpdateCreditCardRequest", + 225: "EMsg_UpdateUserBanResponse", + 226: "EMsg_PrepareToExit", + 227: "EMsg_ContentDescriptionUpdate", + 228: "EMsg_TestResetServer", + 229: "EMsg_UniverseChanged", + 230: "EMsg_ShellConfigInfoUpdate", + 233: "EMsg_RequestWindowsEventLogEntries", + 234: "EMsg_ProvideWindowsEventLogEntries", + 235: "EMsg_ShellSearchLogs", + 236: "EMsg_ShellSearchLogsResponse", + 237: "EMsg_ShellCheckWindowsUpdates", + 238: "EMsg_ShellCheckWindowsUpdatesResponse", + 239: "EMsg_ShellFlushUserLicenseCache", + 300: "EMsg_BaseGM", + 301: "EMsg_ShellFailed", + 307: "EMsg_ExitShells", + 308: "EMsg_ExitShell", + 309: "EMsg_GracefulExitShell", + 314: "EMsg_NotifyWatchdog", + 316: "EMsg_LicenseProcessingComplete", + 317: "EMsg_SetTestFlag", + 318: "EMsg_QueuedEmailsComplete", + 319: "EMsg_GMReportPHPError", + 320: "EMsg_GMDRMSync", + 321: "EMsg_PhysicalBoxInventory", + 322: "EMsg_UpdateConfigFile", + 323: "EMsg_TestInitDB", + 324: "EMsg_GMWriteConfigToSQL", + 325: "EMsg_GMLoadActivationCodes", + 326: "EMsg_GMQueueForFBS", + 327: "EMsg_GMSchemaConversionResults", + 328: "EMsg_GMSchemaConversionResultsResponse", + 329: "EMsg_GMWriteShellFailureToSQL", + 400: "EMsg_BaseAIS", + 401: "EMsg_AISRefreshContentDescription", + 402: "EMsg_AISRequestContentDescription", + 403: "EMsg_AISUpdateAppInfo", + 404: "EMsg_AISUpdatePackageInfo", + 405: "EMsg_AISGetPackageChangeNumber", + 406: "EMsg_AISGetPackageChangeNumberResponse", + 407: "EMsg_AISAppInfoTableChanged", + 408: "EMsg_AISUpdatePackageInfoResponse", + 409: "EMsg_AISCreateMarketingMessage", + 410: "EMsg_AISCreateMarketingMessageResponse", + 411: "EMsg_AISGetMarketingMessage", + 412: "EMsg_AISGetMarketingMessageResponse", + 413: "EMsg_AISUpdateMarketingMessage", + 414: "EMsg_AISUpdateMarketingMessageResponse", + 415: "EMsg_AISRequestMarketingMessageUpdate", + 416: "EMsg_AISDeleteMarketingMessage", + 419: "EMsg_AISGetMarketingTreatments", + 420: "EMsg_AISGetMarketingTreatmentsResponse", + 421: "EMsg_AISRequestMarketingTreatmentUpdate", + 422: "EMsg_AISTestAddPackage", + 423: "EMsg_AIGetAppGCFlags", + 424: "EMsg_AIGetAppGCFlagsResponse", + 425: "EMsg_AIGetAppList", + 426: "EMsg_AIGetAppListResponse", + 427: "EMsg_AIGetAppInfo", + 428: "EMsg_AIGetAppInfoResponse", + 429: "EMsg_AISGetCouponDefinition", + 430: "EMsg_AISGetCouponDefinitionResponse", + 500: "EMsg_BaseAM", + 504: "EMsg_AMUpdateUserBanRequest", + 505: "EMsg_AMAddLicense", + 507: "EMsg_AMBeginProcessingLicenses", + 508: "EMsg_AMSendSystemIMToUser", + 509: "EMsg_AMExtendLicense", + 510: "EMsg_AMAddMinutesToLicense", + 511: "EMsg_AMCancelLicense", + 512: "EMsg_AMInitPurchase", + 513: "EMsg_AMPurchaseResponse", + 514: "EMsg_AMGetFinalPrice", + 515: "EMsg_AMGetFinalPriceResponse", + 516: "EMsg_AMGetLegacyGameKey", + 517: "EMsg_AMGetLegacyGameKeyResponse", + 518: "EMsg_AMFindHungTransactions", + 519: "EMsg_AMSetAccountTrustedRequest", + 521: "EMsg_AMCompletePurchase", + 522: "EMsg_AMCancelPurchase", + 523: "EMsg_AMNewChallenge", + 526: "EMsg_AMFixPendingPurchaseResponse", + 527: "EMsg_AMIsUserBanned", + 528: "EMsg_AMRegisterKey", + 529: "EMsg_AMLoadActivationCodes", + 530: "EMsg_AMLoadActivationCodesResponse", + 531: "EMsg_AMLookupKeyResponse", + 532: "EMsg_AMLookupKey", + 533: "EMsg_AMChatCleanup", + 534: "EMsg_AMClanCleanup", + 535: "EMsg_AMFixPendingRefund", + 536: "EMsg_AMReverseChargeback", + 537: "EMsg_AMReverseChargebackResponse", + 538: "EMsg_AMClanCleanupList", + 539: "EMsg_AMGetLicenses", + 540: "EMsg_AMGetLicensesResponse", + 550: "EMsg_AllowUserToPlayQuery", + 551: "EMsg_AllowUserToPlayResponse", + 552: "EMsg_AMVerfiyUser", + 553: "EMsg_AMClientNotPlaying", + 554: "EMsg_ClientRequestFriendship", + 555: "EMsg_AMRelayPublishStatus", + 556: "EMsg_AMResetCommunityContent", + 557: "EMsg_AMPrimePersonaStateCache", + 558: "EMsg_AMAllowUserContentQuery", + 559: "EMsg_AMAllowUserContentResponse", + 560: "EMsg_AMInitPurchaseResponse", + 561: "EMsg_AMRevokePurchaseResponse", + 562: "EMsg_AMLockProfile", + 563: "EMsg_AMRefreshGuestPasses", + 564: "EMsg_AMInviteUserToClan", + 565: "EMsg_AMAcknowledgeClanInvite", + 566: "EMsg_AMGrantGuestPasses", + 567: "EMsg_AMClanDataUpdated", + 568: "EMsg_AMReloadAccount", + 569: "EMsg_AMClientChatMsgRelay", + 570: "EMsg_AMChatMulti", + 571: "EMsg_AMClientChatInviteRelay", + 572: "EMsg_AMChatInvite", + 573: "EMsg_AMClientJoinChatRelay", + 574: "EMsg_AMClientChatMemberInfoRelay", + 575: "EMsg_AMPublishChatMemberInfo", + 576: "EMsg_AMClientAcceptFriendInvite", + 577: "EMsg_AMChatEnter", + 578: "EMsg_AMClientPublishRemovalFromSource", + 579: "EMsg_AMChatActionResult", + 580: "EMsg_AMFindAccounts", + 581: "EMsg_AMFindAccountsResponse", + 584: "EMsg_AMSetAccountFlags", + 586: "EMsg_AMCreateClan", + 587: "EMsg_AMCreateClanResponse", + 588: "EMsg_AMGetClanDetails", + 589: "EMsg_AMGetClanDetailsResponse", + 590: "EMsg_AMSetPersonaName", + 591: "EMsg_AMSetAvatar", + 592: "EMsg_AMAuthenticateUser", + 593: "EMsg_AMAuthenticateUserResponse", + 594: "EMsg_AMGetAccountFriendsCount", + 595: "EMsg_AMGetAccountFriendsCountResponse", + 596: "EMsg_AMP2PIntroducerMessage", + 597: "EMsg_ClientChatAction", + 598: "EMsg_AMClientChatActionRelay", + 600: "EMsg_BaseVS", + 601: "EMsg_VACResponse", + 602: "EMsg_ReqChallengeTest", + 604: "EMsg_VSMarkCheat", + 605: "EMsg_VSAddCheat", + 606: "EMsg_VSPurgeCodeModDB", + 607: "EMsg_VSGetChallengeResults", + 608: "EMsg_VSChallengeResultText", + 609: "EMsg_VSReportLingerer", + 610: "EMsg_VSRequestManagedChallenge", + 611: "EMsg_VSLoadDBFinished", + 625: "EMsg_BaseDRMS", + 628: "EMsg_DRMBuildBlobRequest", + 629: "EMsg_DRMBuildBlobResponse", + 630: "EMsg_DRMResolveGuidRequest", + 631: "EMsg_DRMResolveGuidResponse", + 633: "EMsg_DRMVariabilityReport", + 634: "EMsg_DRMVariabilityReportResponse", + 635: "EMsg_DRMStabilityReport", + 636: "EMsg_DRMStabilityReportResponse", + 637: "EMsg_DRMDetailsReportRequest", + 638: "EMsg_DRMDetailsReportResponse", + 639: "EMsg_DRMProcessFile", + 640: "EMsg_DRMAdminUpdate", + 641: "EMsg_DRMAdminUpdateResponse", + 642: "EMsg_DRMSync", + 643: "EMsg_DRMSyncResponse", + 644: "EMsg_DRMProcessFileResponse", + 645: "EMsg_DRMEmptyGuidCache", + 646: "EMsg_DRMEmptyGuidCacheResponse", + 650: "EMsg_BaseCS", + 652: "EMsg_CSUserContentRequest", + 700: "EMsg_BaseClient", + 701: "EMsg_ClientLogOn_Deprecated", + 702: "EMsg_ClientAnonLogOn_Deprecated", + 703: "EMsg_ClientHeartBeat", + 704: "EMsg_ClientVACResponse", + 705: "EMsg_ClientGamesPlayed_obsolete", + 706: "EMsg_ClientLogOff", + 707: "EMsg_ClientNoUDPConnectivity", + 708: "EMsg_ClientInformOfCreateAccount", + 709: "EMsg_ClientAckVACBan", + 710: "EMsg_ClientConnectionStats", + 711: "EMsg_ClientInitPurchase", + 712: "EMsg_ClientPingResponse", + 714: "EMsg_ClientRemoveFriend", + 715: "EMsg_ClientGamesPlayedNoDataBlob", + 716: "EMsg_ClientChangeStatus", + 717: "EMsg_ClientVacStatusResponse", + 718: "EMsg_ClientFriendMsg", + 719: "EMsg_ClientGameConnect_obsolete", + 720: "EMsg_ClientGamesPlayed2_obsolete", + 721: "EMsg_ClientGameEnded_obsolete", + 722: "EMsg_ClientGetFinalPrice", + 726: "EMsg_ClientSystemIM", + 727: "EMsg_ClientSystemIMAck", + 728: "EMsg_ClientGetLicenses", + 729: "EMsg_ClientCancelLicense", + 730: "EMsg_ClientGetLegacyGameKey", + 731: "EMsg_ClientContentServerLogOn_Deprecated", + 732: "EMsg_ClientAckVACBan2", + 735: "EMsg_ClientAckMessageByGID", + 736: "EMsg_ClientGetPurchaseReceipts", + 737: "EMsg_ClientAckPurchaseReceipt", + 738: "EMsg_ClientGamesPlayed3_obsolete", + 739: "EMsg_ClientSendGuestPass", + 740: "EMsg_ClientAckGuestPass", + 741: "EMsg_ClientRedeemGuestPass", + 742: "EMsg_ClientGamesPlayed", + 743: "EMsg_ClientRegisterKey", + 744: "EMsg_ClientInviteUserToClan", + 745: "EMsg_ClientAcknowledgeClanInvite", + 746: "EMsg_ClientPurchaseWithMachineID", + 747: "EMsg_ClientAppUsageEvent", + 748: "EMsg_ClientGetGiftTargetList", + 749: "EMsg_ClientGetGiftTargetListResponse", + 751: "EMsg_ClientLogOnResponse", + 753: "EMsg_ClientVACChallenge", + 755: "EMsg_ClientSetHeartbeatRate", + 756: "EMsg_ClientNotLoggedOnDeprecated", + 757: "EMsg_ClientLoggedOff", + 758: "EMsg_GSApprove", + 759: "EMsg_GSDeny", + 760: "EMsg_GSKick", + 761: "EMsg_ClientCreateAcctResponse", + 763: "EMsg_ClientPurchaseResponse", + 764: "EMsg_ClientPing", + 765: "EMsg_ClientNOP", + 766: "EMsg_ClientPersonaState", + 767: "EMsg_ClientFriendsList", + 768: "EMsg_ClientAccountInfo", + 770: "EMsg_ClientVacStatusQuery", + 771: "EMsg_ClientNewsUpdate", + 773: "EMsg_ClientGameConnectDeny", + 774: "EMsg_GSStatusReply", + 775: "EMsg_ClientGetFinalPriceResponse", + 779: "EMsg_ClientGameConnectTokens", + 780: "EMsg_ClientLicenseList", + 781: "EMsg_ClientCancelLicenseResponse", + 782: "EMsg_ClientVACBanStatus", + 783: "EMsg_ClientCMList", + 784: "EMsg_ClientEncryptPct", + 785: "EMsg_ClientGetLegacyGameKeyResponse", + 786: "EMsg_ClientFavoritesList", + 787: "EMsg_CSUserContentApprove", + 788: "EMsg_CSUserContentDeny", + 789: "EMsg_ClientInitPurchaseResponse", + 791: "EMsg_ClientAddFriend", + 792: "EMsg_ClientAddFriendResponse", + 793: "EMsg_ClientInviteFriend", + 794: "EMsg_ClientInviteFriendResponse", + 795: "EMsg_ClientSendGuestPassResponse", + 796: "EMsg_ClientAckGuestPassResponse", + 797: "EMsg_ClientRedeemGuestPassResponse", + 798: "EMsg_ClientUpdateGuestPassesList", + 799: "EMsg_ClientChatMsg", + 800: "EMsg_ClientChatInvite", + 801: "EMsg_ClientJoinChat", + 802: "EMsg_ClientChatMemberInfo", + 803: "EMsg_ClientLogOnWithCredentials_Deprecated", + 805: "EMsg_ClientPasswordChangeResponse", + 807: "EMsg_ClientChatEnter", + 808: "EMsg_ClientFriendRemovedFromSource", + 809: "EMsg_ClientCreateChat", + 810: "EMsg_ClientCreateChatResponse", + 811: "EMsg_ClientUpdateChatMetadata", + 813: "EMsg_ClientP2PIntroducerMessage", + 814: "EMsg_ClientChatActionResult", + 815: "EMsg_ClientRequestFriendData", + 818: "EMsg_ClientGetUserStats", + 819: "EMsg_ClientGetUserStatsResponse", + 820: "EMsg_ClientStoreUserStats", + 821: "EMsg_ClientStoreUserStatsResponse", + 822: "EMsg_ClientClanState", + 830: "EMsg_ClientServiceModule", + 831: "EMsg_ClientServiceCall", + 832: "EMsg_ClientServiceCallResponse", + 833: "EMsg_ClientPackageInfoRequest", + 834: "EMsg_ClientPackageInfoResponse", + 839: "EMsg_ClientNatTraversalStatEvent", + 840: "EMsg_ClientAppInfoRequest", + 841: "EMsg_ClientAppInfoResponse", + 842: "EMsg_ClientSteamUsageEvent", + 845: "EMsg_ClientCheckPassword", + 846: "EMsg_ClientResetPassword", + 848: "EMsg_ClientCheckPasswordResponse", + 849: "EMsg_ClientResetPasswordResponse", + 850: "EMsg_ClientSessionToken", + 851: "EMsg_ClientDRMProblemReport", + 855: "EMsg_ClientSetIgnoreFriend", + 856: "EMsg_ClientSetIgnoreFriendResponse", + 857: "EMsg_ClientGetAppOwnershipTicket", + 858: "EMsg_ClientGetAppOwnershipTicketResponse", + 860: "EMsg_ClientGetLobbyListResponse", + 861: "EMsg_ClientGetLobbyMetadata", + 862: "EMsg_ClientGetLobbyMetadataResponse", + 863: "EMsg_ClientVTTCert", + 866: "EMsg_ClientAppInfoUpdate", + 867: "EMsg_ClientAppInfoChanges", + 880: "EMsg_ClientServerList", + 891: "EMsg_ClientEmailChangeResponse", + 892: "EMsg_ClientSecretQAChangeResponse", + 896: "EMsg_ClientDRMBlobRequest", + 897: "EMsg_ClientDRMBlobResponse", + 898: "EMsg_ClientLookupKey", + 899: "EMsg_ClientLookupKeyResponse", + 900: "EMsg_BaseGameServer", + 901: "EMsg_GSDisconnectNotice", + 903: "EMsg_GSStatus", + 905: "EMsg_GSUserPlaying", + 906: "EMsg_GSStatus2", + 907: "EMsg_GSStatusUpdate_Unused", + 908: "EMsg_GSServerType", + 909: "EMsg_GSPlayerList", + 910: "EMsg_GSGetUserAchievementStatus", + 911: "EMsg_GSGetUserAchievementStatusResponse", + 918: "EMsg_GSGetPlayStats", + 919: "EMsg_GSGetPlayStatsResponse", + 920: "EMsg_GSGetUserGroupStatus", + 921: "EMsg_AMGetUserGroupStatus", + 922: "EMsg_AMGetUserGroupStatusResponse", + 923: "EMsg_GSGetUserGroupStatusResponse", + 936: "EMsg_GSGetReputation", + 937: "EMsg_GSGetReputationResponse", + 938: "EMsg_GSAssociateWithClan", + 939: "EMsg_GSAssociateWithClanResponse", + 940: "EMsg_GSComputeNewPlayerCompatibility", + 941: "EMsg_GSComputeNewPlayerCompatibilityResponse", + 1000: "EMsg_BaseAdmin", + 1004: "EMsg_AdminCmdResponse", + 1005: "EMsg_AdminLogListenRequest", + 1006: "EMsg_AdminLogEvent", + 1007: "EMsg_LogSearchRequest", + 1008: "EMsg_LogSearchResponse", + 1009: "EMsg_LogSearchCancel", + 1010: "EMsg_UniverseData", + 1014: "EMsg_RequestStatHistory", + 1015: "EMsg_StatHistory", + 1017: "EMsg_AdminPwLogon", + 1018: "EMsg_AdminPwLogonResponse", + 1019: "EMsg_AdminSpew", + 1020: "EMsg_AdminConsoleTitle", + 1023: "EMsg_AdminGCSpew", + 1024: "EMsg_AdminGCCommand", + 1025: "EMsg_AdminGCGetCommandList", + 1026: "EMsg_AdminGCGetCommandListResponse", + 1027: "EMsg_FBSConnectionData", + 1028: "EMsg_AdminMsgSpew", + 1100: "EMsg_BaseFBS", + 1101: "EMsg_FBSVersionInfo", + 1102: "EMsg_FBSForceRefresh", + 1103: "EMsg_FBSForceBounce", + 1104: "EMsg_FBSDeployPackage", + 1105: "EMsg_FBSDeployResponse", + 1106: "EMsg_FBSUpdateBootstrapper", + 1107: "EMsg_FBSSetState", + 1108: "EMsg_FBSApplyOSUpdates", + 1109: "EMsg_FBSRunCMDScript", + 1110: "EMsg_FBSRebootBox", + 1111: "EMsg_FBSSetBigBrotherMode", + 1112: "EMsg_FBSMinidumpServer", + 1113: "EMsg_FBSSetShellCount_obsolete", + 1114: "EMsg_FBSDeployHotFixPackage", + 1115: "EMsg_FBSDeployHotFixResponse", + 1116: "EMsg_FBSDownloadHotFix", + 1117: "EMsg_FBSDownloadHotFixResponse", + 1118: "EMsg_FBSUpdateTargetConfigFile", + 1119: "EMsg_FBSApplyAccountCred", + 1120: "EMsg_FBSApplyAccountCredResponse", + 1121: "EMsg_FBSSetShellCount", + 1122: "EMsg_FBSTerminateShell", + 1123: "EMsg_FBSQueryGMForRequest", + 1124: "EMsg_FBSQueryGMResponse", + 1125: "EMsg_FBSTerminateZombies", + 1126: "EMsg_FBSInfoFromBootstrapper", + 1127: "EMsg_FBSRebootBoxResponse", + 1128: "EMsg_FBSBootstrapperPackageRequest", + 1129: "EMsg_FBSBootstrapperPackageResponse", + 1130: "EMsg_FBSBootstrapperGetPackageChunk", + 1131: "EMsg_FBSBootstrapperGetPackageChunkResponse", + 1132: "EMsg_FBSBootstrapperPackageTransferProgress", + 1133: "EMsg_FBSRestartBootstrapper", + 1200: "EMsg_BaseFileXfer", + 1201: "EMsg_FileXferResponse", + 1202: "EMsg_FileXferData", + 1203: "EMsg_FileXferEnd", + 1204: "EMsg_FileXferDataAck", + 1300: "EMsg_BaseChannelAuth", + 1301: "EMsg_ChannelAuthResponse", + 1302: "EMsg_ChannelAuthResult", + 1303: "EMsg_ChannelEncryptRequest", + 1304: "EMsg_ChannelEncryptResponse", + 1305: "EMsg_ChannelEncryptResult", + 1400: "EMsg_BaseBS", + 1401: "EMsg_BSPurchaseStart", + 1402: "EMsg_BSPurchaseResponse", + 1404: "EMsg_BSSettleNOVA", + 1406: "EMsg_BSSettleComplete", + 1407: "EMsg_BSBannedRequest", + 1408: "EMsg_BSInitPayPalTxn", + 1409: "EMsg_BSInitPayPalTxnResponse", + 1410: "EMsg_BSGetPayPalUserInfo", + 1411: "EMsg_BSGetPayPalUserInfoResponse", + 1413: "EMsg_BSRefundTxn", + 1414: "EMsg_BSRefundTxnResponse", + 1415: "EMsg_BSGetEvents", + 1416: "EMsg_BSChaseRFRRequest", + 1417: "EMsg_BSPaymentInstrBan", + 1418: "EMsg_BSPaymentInstrBanResponse", + 1419: "EMsg_BSProcessGCReports", + 1420: "EMsg_BSProcessPPReports", + 1421: "EMsg_BSInitGCBankXferTxn", + 1422: "EMsg_BSInitGCBankXferTxnResponse", + 1423: "EMsg_BSQueryGCBankXferTxn", + 1424: "EMsg_BSQueryGCBankXferTxnResponse", + 1425: "EMsg_BSCommitGCTxn", + 1426: "EMsg_BSQueryTransactionStatus", + 1427: "EMsg_BSQueryTransactionStatusResponse", + 1428: "EMsg_BSQueryCBOrderStatus", + 1429: "EMsg_BSQueryCBOrderStatusResponse", + 1430: "EMsg_BSRunRedFlagReport", + 1431: "EMsg_BSQueryPaymentInstUsage", + 1432: "EMsg_BSQueryPaymentInstResponse", + 1433: "EMsg_BSQueryTxnExtendedInfo", + 1434: "EMsg_BSQueryTxnExtendedInfoResponse", + 1435: "EMsg_BSUpdateConversionRates", + 1436: "EMsg_BSProcessUSBankReports", + 1437: "EMsg_BSPurchaseRunFraudChecks", + 1438: "EMsg_BSPurchaseRunFraudChecksResponse", + 1439: "EMsg_BSStartShippingJobs", + 1440: "EMsg_BSQueryBankInformation", + 1441: "EMsg_BSQueryBankInformationResponse", + 1445: "EMsg_BSValidateXsollaSignature", + 1446: "EMsg_BSValidateXsollaSignatureResponse", + 1448: "EMsg_BSQiwiWalletInvoice", + 1449: "EMsg_BSQiwiWalletInvoiceResponse", + 1450: "EMsg_BSUpdateInventoryFromProPack", + 1451: "EMsg_BSUpdateInventoryFromProPackResponse", + 1452: "EMsg_BSSendShippingRequest", + 1453: "EMsg_BSSendShippingRequestResponse", + 1454: "EMsg_BSGetProPackOrderStatus", + 1455: "EMsg_BSGetProPackOrderStatusResponse", + 1456: "EMsg_BSCheckJobRunning", + 1457: "EMsg_BSCheckJobRunningResponse", + 1458: "EMsg_BSResetPackagePurchaseRateLimit", + 1459: "EMsg_BSResetPackagePurchaseRateLimitResponse", + 1460: "EMsg_BSUpdatePaymentData", + 1461: "EMsg_BSUpdatePaymentDataResponse", + 1462: "EMsg_BSGetBillingAddress", + 1463: "EMsg_BSGetBillingAddressResponse", + 1464: "EMsg_BSGetCreditCardInfo", + 1465: "EMsg_BSGetCreditCardInfoResponse", + 1468: "EMsg_BSRemoveExpiredPaymentData", + 1469: "EMsg_BSRemoveExpiredPaymentDataResponse", + 1470: "EMsg_BSConvertToCurrentKeys", + 1471: "EMsg_BSConvertToCurrentKeysResponse", + 1472: "EMsg_BSInitPurchase", + 1473: "EMsg_BSInitPurchaseResponse", + 1474: "EMsg_BSCompletePurchase", + 1475: "EMsg_BSCompletePurchaseResponse", + 1476: "EMsg_BSPruneCardUsageStats", + 1477: "EMsg_BSPruneCardUsageStatsResponse", + 1478: "EMsg_BSStoreBankInformation", + 1479: "EMsg_BSStoreBankInformationResponse", + 1480: "EMsg_BSVerifyPOSAKey", + 1481: "EMsg_BSVerifyPOSAKeyResponse", + 1482: "EMsg_BSReverseRedeemPOSAKey", + 1483: "EMsg_BSReverseRedeemPOSAKeyResponse", + 1484: "EMsg_BSQueryFindCreditCard", + 1485: "EMsg_BSQueryFindCreditCardResponse", + 1486: "EMsg_BSStatusInquiryPOSAKey", + 1487: "EMsg_BSStatusInquiryPOSAKeyResponse", + 1488: "EMsg_BSValidateMoPaySignature", + 1489: "EMsg_BSValidateMoPaySignatureResponse", + 1490: "EMsg_BSMoPayConfirmProductDelivery", + 1491: "EMsg_BSMoPayConfirmProductDeliveryResponse", + 1492: "EMsg_BSGenerateMoPayMD5", + 1493: "EMsg_BSGenerateMoPayMD5Response", + 1494: "EMsg_BSBoaCompraConfirmProductDelivery", + 1495: "EMsg_BSBoaCompraConfirmProductDeliveryResponse", + 1496: "EMsg_BSGenerateBoaCompraMD5", + 1497: "EMsg_BSGenerateBoaCompraMD5Response", + 1500: "EMsg_BaseATS", + 1501: "EMsg_ATSStartStressTest", + 1502: "EMsg_ATSStopStressTest", + 1503: "EMsg_ATSRunFailServerTest", + 1504: "EMsg_ATSUFSPerfTestTask", + 1505: "EMsg_ATSUFSPerfTestResponse", + 1506: "EMsg_ATSCycleTCM", + 1507: "EMsg_ATSInitDRMSStressTest", + 1508: "EMsg_ATSCallTest", + 1509: "EMsg_ATSCallTestReply", + 1510: "EMsg_ATSStartExternalStress", + 1511: "EMsg_ATSExternalStressJobStart", + 1512: "EMsg_ATSExternalStressJobQueued", + 1513: "EMsg_ATSExternalStressJobRunning", + 1514: "EMsg_ATSExternalStressJobStopped", + 1515: "EMsg_ATSExternalStressJobStopAll", + 1516: "EMsg_ATSExternalStressActionResult", + 1517: "EMsg_ATSStarted", + 1518: "EMsg_ATSCSPerfTestTask", + 1519: "EMsg_ATSCSPerfTestResponse", + 1600: "EMsg_BaseDP", + 1601: "EMsg_DPSetPublishingState", + 1602: "EMsg_DPGamePlayedStats", + 1603: "EMsg_DPUniquePlayersStat", + 1605: "EMsg_DPVacInfractionStats", + 1606: "EMsg_DPVacBanStats", + 1607: "EMsg_DPBlockingStats", + 1608: "EMsg_DPNatTraversalStats", + 1609: "EMsg_DPSteamUsageEvent", + 1610: "EMsg_DPVacCertBanStats", + 1611: "EMsg_DPVacCafeBanStats", + 1612: "EMsg_DPCloudStats", + 1613: "EMsg_DPAchievementStats", + 1614: "EMsg_DPAccountCreationStats", + 1615: "EMsg_DPGetPlayerCount", + 1616: "EMsg_DPGetPlayerCountResponse", + 1617: "EMsg_DPGameServersPlayersStats", + 1618: "EMsg_DPDownloadRateStatistics", + 1619: "EMsg_DPFacebookStatistics", + 1620: "EMsg_ClientDPCheckSpecialSurvey", + 1621: "EMsg_ClientDPCheckSpecialSurveyResponse", + 1622: "EMsg_ClientDPSendSpecialSurveyResponse", + 1623: "EMsg_ClientDPSendSpecialSurveyResponseReply", + 1624: "EMsg_DPStoreSaleStatistics", + 1625: "EMsg_ClientDPUpdateAppJobReport", + 1627: "EMsg_ClientDPSteam2AppStarted", + 1626: "EMsg_DPUpdateContentEvent", + 1630: "EMsg_ClientDPContentStatsReport", + 1700: "EMsg_BaseCM", + 1701: "EMsg_CMSetAllowState", + 1702: "EMsg_CMSpewAllowState", + 1703: "EMsg_CMAppInfoResponseDeprecated", + 1800: "EMsg_BaseDSS", + 1801: "EMsg_DSSNewFile", + 1802: "EMsg_DSSCurrentFileList", + 1803: "EMsg_DSSSynchList", + 1804: "EMsg_DSSSynchListResponse", + 1805: "EMsg_DSSSynchSubscribe", + 1806: "EMsg_DSSSynchUnsubscribe", + 1900: "EMsg_BaseEPM", + 1901: "EMsg_EPMStartProcess", + 1902: "EMsg_EPMStopProcess", + 1903: "EMsg_EPMRestartProcess", + 2200: "EMsg_BaseGC", + 2201: "EMsg_AMRelayToGC", + 2202: "EMsg_GCUpdatePlayedState", + 2203: "EMsg_GCCmdRevive", + 2204: "EMsg_GCCmdBounce", + 2205: "EMsg_GCCmdForceBounce", + 2206: "EMsg_GCCmdDown", + 2207: "EMsg_GCCmdDeploy", + 2208: "EMsg_GCCmdDeployResponse", + 2209: "EMsg_GCCmdSwitch", + 2210: "EMsg_AMRefreshSessions", + 2211: "EMsg_GCUpdateGSState", + 2212: "EMsg_GCAchievementAwarded", + 2213: "EMsg_GCSystemMessage", + 2214: "EMsg_GCValidateSession", + 2215: "EMsg_GCValidateSessionResponse", + 2216: "EMsg_GCCmdStatus", + 2217: "EMsg_GCRegisterWebInterfaces", + 2218: "EMsg_GCGetAccountDetails", + 2219: "EMsg_GCInterAppMessage", + 2220: "EMsg_GCGetEmailTemplate", + 2221: "EMsg_GCGetEmailTemplateResponse", + 2222: "EMsg_ISRelayToGCH", + 2223: "EMsg_GCHRelayClientToIS", + 2224: "EMsg_GCHUpdateSession", + 2225: "EMsg_GCHRequestUpdateSession", + 2226: "EMsg_GCHRequestStatus", + 2227: "EMsg_GCHRequestStatusResponse", + 2500: "EMsg_BaseP2P", + 2502: "EMsg_P2PIntroducerMessage", + 2900: "EMsg_BaseSM", + 2902: "EMsg_SMExpensiveReport", + 2903: "EMsg_SMHourlyReport", + 2904: "EMsg_SMFishingReport", + 2905: "EMsg_SMPartitionRenames", + 2906: "EMsg_SMMonitorSpace", + 2907: "EMsg_SMGetSchemaConversionResults", + 2908: "EMsg_SMGetSchemaConversionResultsResponse", + 3000: "EMsg_BaseTest", + 3001: "EMsg_JobHeartbeatTest", + 3002: "EMsg_JobHeartbeatTestResponse", + 3100: "EMsg_BaseFTSRange", + 3101: "EMsg_FTSGetBrowseCounts", + 3102: "EMsg_FTSGetBrowseCountsResponse", + 3103: "EMsg_FTSBrowseClans", + 3104: "EMsg_FTSBrowseClansResponse", + 3105: "EMsg_FTSSearchClansByLocation", + 3106: "EMsg_FTSSearchClansByLocationResponse", + 3107: "EMsg_FTSSearchPlayersByLocation", + 3108: "EMsg_FTSSearchPlayersByLocationResponse", + 3109: "EMsg_FTSClanDeleted", + 3110: "EMsg_FTSSearch", + 3111: "EMsg_FTSSearchResponse", + 3112: "EMsg_FTSSearchStatus", + 3113: "EMsg_FTSSearchStatusResponse", + 3114: "EMsg_FTSGetGSPlayStats", + 3115: "EMsg_FTSGetGSPlayStatsResponse", + 3116: "EMsg_FTSGetGSPlayStatsForServer", + 3117: "EMsg_FTSGetGSPlayStatsForServerResponse", + 3118: "EMsg_FTSReportIPUpdates", + 3150: "EMsg_BaseCCSRange", + 3151: "EMsg_CCSGetComments", + 3152: "EMsg_CCSGetCommentsResponse", + 3153: "EMsg_CCSAddComment", + 3154: "EMsg_CCSAddCommentResponse", + 3155: "EMsg_CCSDeleteComment", + 3156: "EMsg_CCSDeleteCommentResponse", + 3157: "EMsg_CCSPreloadComments", + 3158: "EMsg_CCSNotifyCommentCount", + 3159: "EMsg_CCSGetCommentsForNews", + 3160: "EMsg_CCSGetCommentsForNewsResponse", + 3161: "EMsg_CCSDeleteAllCommentsByAuthor", + 3162: "EMsg_CCSDeleteAllCommentsByAuthorResponse", + 3200: "EMsg_BaseLBSRange", + 3201: "EMsg_LBSSetScore", + 3202: "EMsg_LBSSetScoreResponse", + 3203: "EMsg_LBSFindOrCreateLB", + 3204: "EMsg_LBSFindOrCreateLBResponse", + 3205: "EMsg_LBSGetLBEntries", + 3206: "EMsg_LBSGetLBEntriesResponse", + 3207: "EMsg_LBSGetLBList", + 3208: "EMsg_LBSGetLBListResponse", + 3209: "EMsg_LBSSetLBDetails", + 3210: "EMsg_LBSDeleteLB", + 3211: "EMsg_LBSDeleteLBEntry", + 3212: "EMsg_LBSResetLB", + 3400: "EMsg_BaseOGS", + 3401: "EMsg_OGSBeginSession", + 3402: "EMsg_OGSBeginSessionResponse", + 3403: "EMsg_OGSEndSession", + 3404: "EMsg_OGSEndSessionResponse", + 3406: "EMsg_OGSWriteAppSessionRow", + 3600: "EMsg_BaseBRP", + 3601: "EMsg_BRPStartShippingJobs", + 3602: "EMsg_BRPProcessUSBankReports", + 3603: "EMsg_BRPProcessGCReports", + 3604: "EMsg_BRPProcessPPReports", + 3605: "EMsg_BRPSettleNOVA", + 3606: "EMsg_BRPSettleCB", + 3607: "EMsg_BRPCommitGC", + 3608: "EMsg_BRPCommitGCResponse", + 3609: "EMsg_BRPFindHungTransactions", + 3610: "EMsg_BRPCheckFinanceCloseOutDate", + 3611: "EMsg_BRPProcessLicenses", + 3612: "EMsg_BRPProcessLicensesResponse", + 3613: "EMsg_BRPRemoveExpiredPaymentData", + 3614: "EMsg_BRPRemoveExpiredPaymentDataResponse", + 3615: "EMsg_BRPConvertToCurrentKeys", + 3616: "EMsg_BRPConvertToCurrentKeysResponse", + 3617: "EMsg_BRPPruneCardUsageStats", + 3618: "EMsg_BRPPruneCardUsageStatsResponse", + 3619: "EMsg_BRPCheckActivationCodes", + 3620: "EMsg_BRPCheckActivationCodesResponse", + 4000: "EMsg_BaseAMRange2", + 4001: "EMsg_AMCreateChat", + 4002: "EMsg_AMCreateChatResponse", + 4003: "EMsg_AMUpdateChatMetadata", + 4004: "EMsg_AMPublishChatMetadata", + 4005: "EMsg_AMSetProfileURL", + 4006: "EMsg_AMGetAccountEmailAddress", + 4007: "EMsg_AMGetAccountEmailAddressResponse", + 4008: "EMsg_AMRequestFriendData", + 4009: "EMsg_AMRouteToClients", + 4010: "EMsg_AMLeaveClan", + 4011: "EMsg_AMClanPermissions", + 4012: "EMsg_AMClanPermissionsResponse", + 4013: "EMsg_AMCreateClanEvent", + 4014: "EMsg_AMCreateClanEventResponse", + 4015: "EMsg_AMUpdateClanEvent", + 4016: "EMsg_AMUpdateClanEventResponse", + 4017: "EMsg_AMGetClanEvents", + 4018: "EMsg_AMGetClanEventsResponse", + 4019: "EMsg_AMDeleteClanEvent", + 4020: "EMsg_AMDeleteClanEventResponse", + 4021: "EMsg_AMSetClanPermissionSettings", + 4022: "EMsg_AMSetClanPermissionSettingsResponse", + 4023: "EMsg_AMGetClanPermissionSettings", + 4024: "EMsg_AMGetClanPermissionSettingsResponse", + 4025: "EMsg_AMPublishChatRoomInfo", + 4026: "EMsg_ClientChatRoomInfo", + 4027: "EMsg_AMCreateClanAnnouncement", + 4028: "EMsg_AMCreateClanAnnouncementResponse", + 4029: "EMsg_AMUpdateClanAnnouncement", + 4030: "EMsg_AMUpdateClanAnnouncementResponse", + 4031: "EMsg_AMGetClanAnnouncementsCount", + 4032: "EMsg_AMGetClanAnnouncementsCountResponse", + 4033: "EMsg_AMGetClanAnnouncements", + 4034: "EMsg_AMGetClanAnnouncementsResponse", + 4035: "EMsg_AMDeleteClanAnnouncement", + 4036: "EMsg_AMDeleteClanAnnouncementResponse", + 4037: "EMsg_AMGetSingleClanAnnouncement", + 4038: "EMsg_AMGetSingleClanAnnouncementResponse", + 4039: "EMsg_AMGetClanHistory", + 4040: "EMsg_AMGetClanHistoryResponse", + 4041: "EMsg_AMGetClanPermissionBits", + 4042: "EMsg_AMGetClanPermissionBitsResponse", + 4043: "EMsg_AMSetClanPermissionBits", + 4044: "EMsg_AMSetClanPermissionBitsResponse", + 4045: "EMsg_AMSessionInfoRequest", + 4046: "EMsg_AMSessionInfoResponse", + 4047: "EMsg_AMValidateWGToken", + 4048: "EMsg_AMGetSingleClanEvent", + 4049: "EMsg_AMGetSingleClanEventResponse", + 4050: "EMsg_AMGetClanRank", + 4051: "EMsg_AMGetClanRankResponse", + 4052: "EMsg_AMSetClanRank", + 4053: "EMsg_AMSetClanRankResponse", + 4054: "EMsg_AMGetClanPOTW", + 4055: "EMsg_AMGetClanPOTWResponse", + 4056: "EMsg_AMSetClanPOTW", + 4057: "EMsg_AMSetClanPOTWResponse", + 4058: "EMsg_AMRequestChatMetadata", + 4059: "EMsg_AMDumpUser", + 4060: "EMsg_AMKickUserFromClan", + 4061: "EMsg_AMAddFounderToClan", + 4062: "EMsg_AMValidateWGTokenResponse", + 4063: "EMsg_AMSetCommunityState", + 4064: "EMsg_AMSetAccountDetails", + 4065: "EMsg_AMGetChatBanList", + 4066: "EMsg_AMGetChatBanListResponse", + 4067: "EMsg_AMUnBanFromChat", + 4068: "EMsg_AMSetClanDetails", + 4069: "EMsg_AMGetAccountLinks", + 4070: "EMsg_AMGetAccountLinksResponse", + 4071: "EMsg_AMSetAccountLinks", + 4072: "EMsg_AMSetAccountLinksResponse", + 4073: "EMsg_AMGetUserGameStats", + 4074: "EMsg_AMGetUserGameStatsResponse", + 4075: "EMsg_AMCheckClanMembership", + 4076: "EMsg_AMGetClanMembers", + 4077: "EMsg_AMGetClanMembersResponse", + 4078: "EMsg_AMJoinPublicClan", + 4079: "EMsg_AMNotifyChatOfClanChange", + 4080: "EMsg_AMResubmitPurchase", + 4081: "EMsg_AMAddFriend", + 4082: "EMsg_AMAddFriendResponse", + 4083: "EMsg_AMRemoveFriend", + 4084: "EMsg_AMDumpClan", + 4085: "EMsg_AMChangeClanOwner", + 4086: "EMsg_AMCancelEasyCollect", + 4087: "EMsg_AMCancelEasyCollectResponse", + 4088: "EMsg_AMGetClanMembershipList", + 4089: "EMsg_AMGetClanMembershipListResponse", + 4090: "EMsg_AMClansInCommon", + 4091: "EMsg_AMClansInCommonResponse", + 4092: "EMsg_AMIsValidAccountID", + 4093: "EMsg_AMConvertClan", + 4094: "EMsg_AMGetGiftTargetListRelay", + 4095: "EMsg_AMWipeFriendsList", + 4096: "EMsg_AMSetIgnored", + 4097: "EMsg_AMClansInCommonCountResponse", + 4098: "EMsg_AMFriendsList", + 4099: "EMsg_AMFriendsListResponse", + 4100: "EMsg_AMFriendsInCommon", + 4101: "EMsg_AMFriendsInCommonResponse", + 4102: "EMsg_AMFriendsInCommonCountResponse", + 4103: "EMsg_AMClansInCommonCount", + 4104: "EMsg_AMChallengeVerdict", + 4105: "EMsg_AMChallengeNotification", + 4106: "EMsg_AMFindGSByIP", + 4107: "EMsg_AMFoundGSByIP", + 4108: "EMsg_AMGiftRevoked", + 4109: "EMsg_AMCreateAccountRecord", + 4110: "EMsg_AMUserClanList", + 4111: "EMsg_AMUserClanListResponse", + 4112: "EMsg_AMGetAccountDetails2", + 4113: "EMsg_AMGetAccountDetailsResponse2", + 4114: "EMsg_AMSetCommunityProfileSettings", + 4115: "EMsg_AMSetCommunityProfileSettingsResponse", + 4116: "EMsg_AMGetCommunityPrivacyState", + 4117: "EMsg_AMGetCommunityPrivacyStateResponse", + 4118: "EMsg_AMCheckClanInviteRateLimiting", + 4119: "EMsg_AMGetUserAchievementStatus", + 4120: "EMsg_AMGetIgnored", + 4121: "EMsg_AMGetIgnoredResponse", + 4122: "EMsg_AMSetIgnoredResponse", + 4123: "EMsg_AMSetFriendRelationshipNone", + 4124: "EMsg_AMGetFriendRelationship", + 4125: "EMsg_AMGetFriendRelationshipResponse", + 4126: "EMsg_AMServiceModulesCache", + 4127: "EMsg_AMServiceModulesCall", + 4128: "EMsg_AMServiceModulesCallResponse", + 4129: "EMsg_AMGetCaptchaDataForIP", + 4130: "EMsg_AMGetCaptchaDataForIPResponse", + 4131: "EMsg_AMValidateCaptchaDataForIP", + 4132: "EMsg_AMValidateCaptchaDataForIPResponse", + 4133: "EMsg_AMTrackFailedAuthByIP", + 4134: "EMsg_AMGetCaptchaDataByGID", + 4135: "EMsg_AMGetCaptchaDataByGIDResponse", + 4136: "EMsg_AMGetLobbyList", + 4137: "EMsg_AMGetLobbyListResponse", + 4138: "EMsg_AMGetLobbyMetadata", + 4139: "EMsg_AMGetLobbyMetadataResponse", + 4140: "EMsg_CommunityAddFriendNews", + 4141: "EMsg_AMAddClanNews", + 4142: "EMsg_AMWriteNews", + 4143: "EMsg_AMFindClanUser", + 4144: "EMsg_AMFindClanUserResponse", + 4145: "EMsg_AMBanFromChat", + 4146: "EMsg_AMGetUserHistoryResponse", + 4147: "EMsg_AMGetUserNewsSubscriptions", + 4148: "EMsg_AMGetUserNewsSubscriptionsResponse", + 4149: "EMsg_AMSetUserNewsSubscriptions", + 4150: "EMsg_AMGetUserNews", + 4151: "EMsg_AMGetUserNewsResponse", + 4152: "EMsg_AMSendQueuedEmails", + 4153: "EMsg_AMSetLicenseFlags", + 4154: "EMsg_AMGetUserHistory", + 4155: "EMsg_CommunityDeleteUserNews", + 4156: "EMsg_AMAllowUserFilesRequest", + 4157: "EMsg_AMAllowUserFilesResponse", + 4158: "EMsg_AMGetAccountStatus", + 4159: "EMsg_AMGetAccountStatusResponse", + 4160: "EMsg_AMEditBanReason", + 4161: "EMsg_AMCheckClanMembershipResponse", + 4162: "EMsg_AMProbeClanMembershipList", + 4163: "EMsg_AMProbeClanMembershipListResponse", + 4165: "EMsg_AMGetFriendsLobbies", + 4166: "EMsg_AMGetFriendsLobbiesResponse", + 4172: "EMsg_AMGetUserFriendNewsResponse", + 4173: "EMsg_CommunityGetUserFriendNews", + 4174: "EMsg_AMGetUserClansNewsResponse", + 4175: "EMsg_AMGetUserClansNews", + 4176: "EMsg_AMStoreInitPurchase", + 4177: "EMsg_AMStoreInitPurchaseResponse", + 4178: "EMsg_AMStoreGetFinalPrice", + 4179: "EMsg_AMStoreGetFinalPriceResponse", + 4180: "EMsg_AMStoreCompletePurchase", + 4181: "EMsg_AMStoreCancelPurchase", + 4182: "EMsg_AMStorePurchaseResponse", + 4183: "EMsg_AMCreateAccountRecordInSteam3", + 4184: "EMsg_AMGetPreviousCBAccount", + 4185: "EMsg_AMGetPreviousCBAccountResponse", + 4186: "EMsg_AMUpdateBillingAddress", + 4187: "EMsg_AMUpdateBillingAddressResponse", + 4188: "EMsg_AMGetBillingAddress", + 4189: "EMsg_AMGetBillingAddressResponse", + 4190: "EMsg_AMGetUserLicenseHistory", + 4191: "EMsg_AMGetUserLicenseHistoryResponse", + 4194: "EMsg_AMSupportChangePassword", + 4195: "EMsg_AMSupportChangeEmail", + 4196: "EMsg_AMSupportChangeSecretQA", + 4197: "EMsg_AMResetUserVerificationGSByIP", + 4198: "EMsg_AMUpdateGSPlayStats", + 4199: "EMsg_AMSupportEnableOrDisable", + 4200: "EMsg_AMGetComments", + 4201: "EMsg_AMGetCommentsResponse", + 4202: "EMsg_AMAddComment", + 4203: "EMsg_AMAddCommentResponse", + 4204: "EMsg_AMDeleteComment", + 4205: "EMsg_AMDeleteCommentResponse", + 4206: "EMsg_AMGetPurchaseStatus", + 4209: "EMsg_AMSupportIsAccountEnabled", + 4210: "EMsg_AMSupportIsAccountEnabledResponse", + 4211: "EMsg_AMGetUserStats", + 4212: "EMsg_AMSupportKickSession", + 4213: "EMsg_AMGSSearch", + 4216: "EMsg_MarketingMessageUpdate", + 4219: "EMsg_AMRouteFriendMsg", + 4220: "EMsg_AMTicketAuthRequestOrResponse", + 4222: "EMsg_AMVerifyDepotManagementRights", + 4223: "EMsg_AMVerifyDepotManagementRightsResponse", + 4224: "EMsg_AMAddFreeLicense", + 4225: "EMsg_AMGetUserFriendsMinutesPlayed", + 4226: "EMsg_AMGetUserFriendsMinutesPlayedResponse", + 4227: "EMsg_AMGetUserMinutesPlayed", + 4228: "EMsg_AMGetUserMinutesPlayedResponse", + 4231: "EMsg_AMValidateEmailLink", + 4232: "EMsg_AMValidateEmailLinkResponse", + 4234: "EMsg_AMAddUsersToMarketingTreatment", + 4236: "EMsg_AMStoreUserStats", + 4237: "EMsg_AMGetUserGameplayInfo", + 4238: "EMsg_AMGetUserGameplayInfoResponse", + 4239: "EMsg_AMGetCardList", + 4240: "EMsg_AMGetCardListResponse", + 4241: "EMsg_AMDeleteStoredCard", + 4242: "EMsg_AMRevokeLegacyGameKeys", + 4244: "EMsg_AMGetWalletDetails", + 4245: "EMsg_AMGetWalletDetailsResponse", + 4246: "EMsg_AMDeleteStoredPaymentInfo", + 4247: "EMsg_AMGetStoredPaymentSummary", + 4248: "EMsg_AMGetStoredPaymentSummaryResponse", + 4249: "EMsg_AMGetWalletConversionRate", + 4250: "EMsg_AMGetWalletConversionRateResponse", + 4251: "EMsg_AMConvertWallet", + 4252: "EMsg_AMConvertWalletResponse", + 4253: "EMsg_AMRelayGetFriendsWhoPlayGame", + 4254: "EMsg_AMRelayGetFriendsWhoPlayGameResponse", + 4255: "EMsg_AMSetPreApproval", + 4256: "EMsg_AMSetPreApprovalResponse", + 4257: "EMsg_AMMarketingTreatmentUpdate", + 4258: "EMsg_AMCreateRefund", + 4259: "EMsg_AMCreateRefundResponse", + 4260: "EMsg_AMCreateChargeback", + 4261: "EMsg_AMCreateChargebackResponse", + 4262: "EMsg_AMCreateDispute", + 4263: "EMsg_AMCreateDisputeResponse", + 4264: "EMsg_AMClearDispute", + 4265: "EMsg_AMClearDisputeResponse", + 4266: "EMsg_AMPlayerNicknameList", + 4267: "EMsg_AMPlayerNicknameListResponse", + 4268: "EMsg_AMSetDRMTestConfig", + 4269: "EMsg_AMGetUserCurrentGameInfo", + 4270: "EMsg_AMGetUserCurrentGameInfoResponse", + 4271: "EMsg_AMGetGSPlayerList", + 4272: "EMsg_AMGetGSPlayerListResponse", + 4275: "EMsg_AMUpdatePersonaStateCache", + 4276: "EMsg_AMGetGameMembers", + 4277: "EMsg_AMGetGameMembersResponse", + 4278: "EMsg_AMGetSteamIDForMicroTxn", + 4279: "EMsg_AMGetSteamIDForMicroTxnResponse", + 4280: "EMsg_AMAddPublisherUser", + 4281: "EMsg_AMRemovePublisherUser", + 4282: "EMsg_AMGetUserLicenseList", + 4283: "EMsg_AMGetUserLicenseListResponse", + 4284: "EMsg_AMReloadGameGroupPolicy", + 4285: "EMsg_AMAddFreeLicenseResponse", + 4286: "EMsg_AMVACStatusUpdate", + 4287: "EMsg_AMGetAccountDetails", + 4288: "EMsg_AMGetAccountDetailsResponse", + 4289: "EMsg_AMGetPlayerLinkDetails", + 4290: "EMsg_AMGetPlayerLinkDetailsResponse", + 4291: "EMsg_AMSubscribeToPersonaFeed", + 4292: "EMsg_AMGetUserVacBanList", + 4293: "EMsg_AMGetUserVacBanListResponse", + 4294: "EMsg_AMGetAccountFlagsForWGSpoofing", + 4295: "EMsg_AMGetAccountFlagsForWGSpoofingResponse", + 4296: "EMsg_AMGetFriendsWishlistInfo", + 4297: "EMsg_AMGetFriendsWishlistInfoResponse", + 4298: "EMsg_AMGetClanOfficers", + 4299: "EMsg_AMGetClanOfficersResponse", + 4300: "EMsg_AMNameChange", + 4301: "EMsg_AMGetNameHistory", + 4302: "EMsg_AMGetNameHistoryResponse", + 4305: "EMsg_AMUpdateProviderStatus", + 4306: "EMsg_AMClearPersonaMetadataBlob", + 4307: "EMsg_AMSupportRemoveAccountSecurity", + 4308: "EMsg_AMIsAccountInCaptchaGracePeriod", + 4309: "EMsg_AMIsAccountInCaptchaGracePeriodResponse", + 4310: "EMsg_AMAccountPS3Unlink", + 4311: "EMsg_AMAccountPS3UnlinkResponse", + 4312: "EMsg_AMStoreUserStatsResponse", + 4313: "EMsg_AMGetAccountPSNInfo", + 4314: "EMsg_AMGetAccountPSNInfoResponse", + 4315: "EMsg_AMAuthenticatedPlayerList", + 4316: "EMsg_AMGetUserGifts", + 4317: "EMsg_AMGetUserGiftsResponse", + 4320: "EMsg_AMTransferLockedGifts", + 4321: "EMsg_AMTransferLockedGiftsResponse", + 4322: "EMsg_AMPlayerHostedOnGameServer", + 4323: "EMsg_AMGetAccountBanInfo", + 4324: "EMsg_AMGetAccountBanInfoResponse", + 4325: "EMsg_AMRecordBanEnforcement", + 4326: "EMsg_AMRollbackGiftTransfer", + 4327: "EMsg_AMRollbackGiftTransferResponse", + 4328: "EMsg_AMHandlePendingTransaction", + 4329: "EMsg_AMRequestClanDetails", + 4330: "EMsg_AMDeleteStoredPaypalAgreement", + 4331: "EMsg_AMGameServerUpdate", + 4332: "EMsg_AMGameServerRemove", + 4333: "EMsg_AMGetPaypalAgreements", + 4334: "EMsg_AMGetPaypalAgreementsResponse", + 4335: "EMsg_AMGameServerPlayerCompatibilityCheck", + 4336: "EMsg_AMGameServerPlayerCompatibilityCheckResponse", + 4337: "EMsg_AMRenewLicense", + 4338: "EMsg_AMGetAccountCommunityBanInfo", + 4339: "EMsg_AMGetAccountCommunityBanInfoResponse", + 4340: "EMsg_AMGameServerAccountChangePassword", + 4341: "EMsg_AMGameServerAccountDeleteAccount", + 4342: "EMsg_AMRenewAgreement", + 4343: "EMsg_AMSendEmail", + 4344: "EMsg_AMXsollaPayment", + 4345: "EMsg_AMXsollaPaymentResponse", + 4346: "EMsg_AMAcctAllowedToPurchase", + 4347: "EMsg_AMAcctAllowedToPurchaseResponse", + 4348: "EMsg_AMSwapKioskDeposit", + 4349: "EMsg_AMSwapKioskDepositResponse", + 4350: "EMsg_AMSetUserGiftUnowned", + 4351: "EMsg_AMSetUserGiftUnownedResponse", + 4352: "EMsg_AMClaimUnownedUserGift", + 4353: "EMsg_AMClaimUnownedUserGiftResponse", + 4354: "EMsg_AMSetClanName", + 4355: "EMsg_AMSetClanNameResponse", + 4356: "EMsg_AMGrantCoupon", + 4357: "EMsg_AMGrantCouponResponse", + 4358: "EMsg_AMIsPackageRestrictedInUserCountry", + 4359: "EMsg_AMIsPackageRestrictedInUserCountryResponse", + 4360: "EMsg_AMHandlePendingTransactionResponse", + 4361: "EMsg_AMGrantGuestPasses2", + 4362: "EMsg_AMGrantGuestPasses2Response", + 4363: "EMsg_AMSessionQuery", + 4364: "EMsg_AMSessionQueryResponse", + 4365: "EMsg_AMGetPlayerBanDetails", + 4366: "EMsg_AMGetPlayerBanDetailsResponse", + 4367: "EMsg_AMFinalizePurchase", + 4368: "EMsg_AMFinalizePurchaseResponse", + 4372: "EMsg_AMPersonaChangeResponse", + 4373: "EMsg_AMGetClanDetailsForForumCreation", + 4374: "EMsg_AMGetClanDetailsForForumCreationResponse", + 4375: "EMsg_AMGetPendingNotificationCount", + 4376: "EMsg_AMGetPendingNotificationCountResponse", + 4377: "EMsg_AMPasswordHashUpgrade", + 4378: "EMsg_AMMoPayPayment", + 4379: "EMsg_AMMoPayPaymentResponse", + 4380: "EMsg_AMBoaCompraPayment", + 4381: "EMsg_AMBoaCompraPaymentResponse", + 4382: "EMsg_AMExpireCaptchaByGID", + 4383: "EMsg_AMCompleteExternalPurchase", + 4384: "EMsg_AMCompleteExternalPurchaseResponse", + 4385: "EMsg_AMResolveNegativeWalletCredits", + 4386: "EMsg_AMResolveNegativeWalletCreditsResponse", + 4387: "EMsg_AMPayelpPayment", + 4388: "EMsg_AMPayelpPaymentResponse", + 4389: "EMsg_AMPlayerGetClanBasicDetails", + 4390: "EMsg_AMPlayerGetClanBasicDetailsResponse", + 4402: "EMsg_AMTwoFactorRecoverAuthenticatorRequest", + 4403: "EMsg_AMTwoFactorRecoverAuthenticatorResponse", + 4406: "EMsg_AMValidatePasswordResetCodeAndSendSmsRequest", + 4407: "EMsg_AMValidatePasswordResetCodeAndSendSmsResponse", + 4408: "EMsg_AMGetAccountResetDetailsRequest", + 4409: "EMsg_AMGetAccountResetDetailsResponse", + 5000: "EMsg_BasePSRange", + 5001: "EMsg_PSCreateShoppingCart", + 5002: "EMsg_PSCreateShoppingCartResponse", + 5003: "EMsg_PSIsValidShoppingCart", + 5004: "EMsg_PSIsValidShoppingCartResponse", + 5005: "EMsg_PSAddPackageToShoppingCart", + 5006: "EMsg_PSAddPackageToShoppingCartResponse", + 5007: "EMsg_PSRemoveLineItemFromShoppingCart", + 5008: "EMsg_PSRemoveLineItemFromShoppingCartResponse", + 5009: "EMsg_PSGetShoppingCartContents", + 5010: "EMsg_PSGetShoppingCartContentsResponse", + 5011: "EMsg_PSAddWalletCreditToShoppingCart", + 5012: "EMsg_PSAddWalletCreditToShoppingCartResponse", + 5200: "EMsg_BaseUFSRange", + 5202: "EMsg_ClientUFSUploadFileRequest", + 5203: "EMsg_ClientUFSUploadFileResponse", + 5204: "EMsg_ClientUFSUploadFileChunk", + 5205: "EMsg_ClientUFSUploadFileFinished", + 5206: "EMsg_ClientUFSGetFileListForApp", + 5207: "EMsg_ClientUFSGetFileListForAppResponse", + 5210: "EMsg_ClientUFSDownloadRequest", + 5211: "EMsg_ClientUFSDownloadResponse", + 5212: "EMsg_ClientUFSDownloadChunk", + 5213: "EMsg_ClientUFSLoginRequest", + 5214: "EMsg_ClientUFSLoginResponse", + 5215: "EMsg_UFSReloadPartitionInfo", + 5216: "EMsg_ClientUFSTransferHeartbeat", + 5217: "EMsg_UFSSynchronizeFile", + 5218: "EMsg_UFSSynchronizeFileResponse", + 5219: "EMsg_ClientUFSDeleteFileRequest", + 5220: "EMsg_ClientUFSDeleteFileResponse", + 5221: "EMsg_UFSDownloadRequest", + 5222: "EMsg_UFSDownloadResponse", + 5223: "EMsg_UFSDownloadChunk", + 5226: "EMsg_ClientUFSGetUGCDetails", + 5227: "EMsg_ClientUFSGetUGCDetailsResponse", + 5228: "EMsg_UFSUpdateFileFlags", + 5229: "EMsg_UFSUpdateFileFlagsResponse", + 5230: "EMsg_ClientUFSGetSingleFileInfo", + 5231: "EMsg_ClientUFSGetSingleFileInfoResponse", + 5232: "EMsg_ClientUFSShareFile", + 5233: "EMsg_ClientUFSShareFileResponse", + 5234: "EMsg_UFSReloadAccount", + 5235: "EMsg_UFSReloadAccountResponse", + 5236: "EMsg_UFSUpdateRecordBatched", + 5237: "EMsg_UFSUpdateRecordBatchedResponse", + 5238: "EMsg_UFSMigrateFile", + 5239: "EMsg_UFSMigrateFileResponse", + 5240: "EMsg_UFSGetUGCURLs", + 5241: "EMsg_UFSGetUGCURLsResponse", + 5242: "EMsg_UFSHttpUploadFileFinishRequest", + 5243: "EMsg_UFSHttpUploadFileFinishResponse", + 5244: "EMsg_UFSDownloadStartRequest", + 5245: "EMsg_UFSDownloadStartResponse", + 5246: "EMsg_UFSDownloadChunkRequest", + 5247: "EMsg_UFSDownloadChunkResponse", + 5248: "EMsg_UFSDownloadFinishRequest", + 5249: "EMsg_UFSDownloadFinishResponse", + 5250: "EMsg_UFSFlushURLCache", + 5251: "EMsg_UFSUploadCommit", + 5252: "EMsg_UFSUploadCommitResponse", + 5400: "EMsg_BaseClient2", + 5401: "EMsg_ClientRequestForgottenPasswordEmail", + 5402: "EMsg_ClientRequestForgottenPasswordEmailResponse", + 5403: "EMsg_ClientCreateAccountResponse", + 5404: "EMsg_ClientResetForgottenPassword", + 5405: "EMsg_ClientResetForgottenPasswordResponse", + 5406: "EMsg_ClientCreateAccount2", + 5407: "EMsg_ClientInformOfResetForgottenPassword", + 5408: "EMsg_ClientInformOfResetForgottenPasswordResponse", + 5409: "EMsg_ClientAnonUserLogOn_Deprecated", + 5410: "EMsg_ClientGamesPlayedWithDataBlob", + 5411: "EMsg_ClientUpdateUserGameInfo", + 5412: "EMsg_ClientFileToDownload", + 5413: "EMsg_ClientFileToDownloadResponse", + 5414: "EMsg_ClientLBSSetScore", + 5415: "EMsg_ClientLBSSetScoreResponse", + 5416: "EMsg_ClientLBSFindOrCreateLB", + 5417: "EMsg_ClientLBSFindOrCreateLBResponse", + 5418: "EMsg_ClientLBSGetLBEntries", + 5419: "EMsg_ClientLBSGetLBEntriesResponse", + 5420: "EMsg_ClientMarketingMessageUpdate", + 5426: "EMsg_ClientChatDeclined", + 5427: "EMsg_ClientFriendMsgIncoming", + 5428: "EMsg_ClientAuthList_Deprecated", + 5429: "EMsg_ClientTicketAuthComplete", + 5430: "EMsg_ClientIsLimitedAccount", + 5431: "EMsg_ClientRequestAuthList", + 5432: "EMsg_ClientAuthList", + 5433: "EMsg_ClientStat", + 5434: "EMsg_ClientP2PConnectionInfo", + 5435: "EMsg_ClientP2PConnectionFailInfo", + 5436: "EMsg_ClientGetNumberOfCurrentPlayers", + 5437: "EMsg_ClientGetNumberOfCurrentPlayersResponse", + 5438: "EMsg_ClientGetDepotDecryptionKey", + 5439: "EMsg_ClientGetDepotDecryptionKeyResponse", + 5440: "EMsg_GSPerformHardwareSurvey", + 5441: "EMsg_ClientGetAppBetaPasswords", + 5442: "EMsg_ClientGetAppBetaPasswordsResponse", + 5443: "EMsg_ClientEnableTestLicense", + 5444: "EMsg_ClientEnableTestLicenseResponse", + 5445: "EMsg_ClientDisableTestLicense", + 5446: "EMsg_ClientDisableTestLicenseResponse", + 5448: "EMsg_ClientRequestValidationMail", + 5449: "EMsg_ClientRequestValidationMailResponse", + 5450: "EMsg_ClientCheckAppBetaPassword", + 5451: "EMsg_ClientCheckAppBetaPasswordResponse", + 5452: "EMsg_ClientToGC", + 5453: "EMsg_ClientFromGC", + 5454: "EMsg_ClientRequestChangeMail", + 5455: "EMsg_ClientRequestChangeMailResponse", + 5456: "EMsg_ClientEmailAddrInfo", + 5457: "EMsg_ClientPasswordChange3", + 5458: "EMsg_ClientEmailChange3", + 5459: "EMsg_ClientPersonalQAChange3", + 5460: "EMsg_ClientResetForgottenPassword3", + 5461: "EMsg_ClientRequestForgottenPasswordEmail3", + 5462: "EMsg_ClientCreateAccount3", + 5463: "EMsg_ClientNewLoginKey", + 5464: "EMsg_ClientNewLoginKeyAccepted", + 5465: "EMsg_ClientLogOnWithHash_Deprecated", + 5466: "EMsg_ClientStoreUserStats2", + 5467: "EMsg_ClientStatsUpdated", + 5468: "EMsg_ClientActivateOEMLicense", + 5469: "EMsg_ClientRegisterOEMMachine", + 5470: "EMsg_ClientRegisterOEMMachineResponse", + 5480: "EMsg_ClientRequestedClientStats", + 5481: "EMsg_ClientStat2Int32", + 5482: "EMsg_ClientStat2", + 5483: "EMsg_ClientVerifyPassword", + 5484: "EMsg_ClientVerifyPasswordResponse", + 5485: "EMsg_ClientDRMDownloadRequest", + 5486: "EMsg_ClientDRMDownloadResponse", + 5487: "EMsg_ClientDRMFinalResult", + 5488: "EMsg_ClientGetFriendsWhoPlayGame", + 5489: "EMsg_ClientGetFriendsWhoPlayGameResponse", + 5490: "EMsg_ClientOGSBeginSession", + 5491: "EMsg_ClientOGSBeginSessionResponse", + 5492: "EMsg_ClientOGSEndSession", + 5493: "EMsg_ClientOGSEndSessionResponse", + 5494: "EMsg_ClientOGSWriteRow", + 5495: "EMsg_ClientDRMTest", + 5496: "EMsg_ClientDRMTestResult", + 5500: "EMsg_ClientServerUnavailable", + 5501: "EMsg_ClientServersAvailable", + 5502: "EMsg_ClientRegisterAuthTicketWithCM", + 5503: "EMsg_ClientGCMsgFailed", + 5504: "EMsg_ClientMicroTxnAuthRequest", + 5505: "EMsg_ClientMicroTxnAuthorize", + 5506: "EMsg_ClientMicroTxnAuthorizeResponse", + 5507: "EMsg_ClientAppMinutesPlayedData", + 5508: "EMsg_ClientGetMicroTxnInfo", + 5509: "EMsg_ClientGetMicroTxnInfoResponse", + 5510: "EMsg_ClientMarketingMessageUpdate2", + 5511: "EMsg_ClientDeregisterWithServer", + 5512: "EMsg_ClientSubscribeToPersonaFeed", + 5514: "EMsg_ClientLogon", + 5515: "EMsg_ClientGetClientDetails", + 5516: "EMsg_ClientGetClientDetailsResponse", + 5517: "EMsg_ClientReportOverlayDetourFailure", + 5518: "EMsg_ClientGetClientAppList", + 5519: "EMsg_ClientGetClientAppListResponse", + 5520: "EMsg_ClientInstallClientApp", + 5521: "EMsg_ClientInstallClientAppResponse", + 5522: "EMsg_ClientUninstallClientApp", + 5523: "EMsg_ClientUninstallClientAppResponse", + 5524: "EMsg_ClientSetClientAppUpdateState", + 5525: "EMsg_ClientSetClientAppUpdateStateResponse", + 5526: "EMsg_ClientRequestEncryptedAppTicket", + 5527: "EMsg_ClientRequestEncryptedAppTicketResponse", + 5528: "EMsg_ClientWalletInfoUpdate", + 5529: "EMsg_ClientLBSSetUGC", + 5530: "EMsg_ClientLBSSetUGCResponse", + 5531: "EMsg_ClientAMGetClanOfficers", + 5532: "EMsg_ClientAMGetClanOfficersResponse", + 5533: "EMsg_ClientCheckFileSignature", + 5534: "EMsg_ClientCheckFileSignatureResponse", + 5535: "EMsg_ClientFriendProfileInfo", + 5536: "EMsg_ClientFriendProfileInfoResponse", + 5537: "EMsg_ClientUpdateMachineAuth", + 5538: "EMsg_ClientUpdateMachineAuthResponse", + 5539: "EMsg_ClientReadMachineAuth", + 5540: "EMsg_ClientReadMachineAuthResponse", + 5541: "EMsg_ClientRequestMachineAuth", + 5542: "EMsg_ClientRequestMachineAuthResponse", + 5543: "EMsg_ClientScreenshotsChanged", + 5544: "EMsg_ClientEmailChange4", + 5545: "EMsg_ClientEmailChangeResponse4", + 5546: "EMsg_ClientGetCDNAuthToken", + 5547: "EMsg_ClientGetCDNAuthTokenResponse", + 5548: "EMsg_ClientDownloadRateStatistics", + 5549: "EMsg_ClientRequestAccountData", + 5550: "EMsg_ClientRequestAccountDataResponse", + 5551: "EMsg_ClientResetForgottenPassword4", + 5552: "EMsg_ClientHideFriend", + 5553: "EMsg_ClientFriendsGroupsList", + 5554: "EMsg_ClientGetClanActivityCounts", + 5555: "EMsg_ClientGetClanActivityCountsResponse", + 5556: "EMsg_ClientOGSReportString", + 5557: "EMsg_ClientOGSReportBug", + 5558: "EMsg_ClientSentLogs", + 5559: "EMsg_ClientLogonGameServer", + 5560: "EMsg_AMClientCreateFriendsGroup", + 5561: "EMsg_AMClientCreateFriendsGroupResponse", + 5562: "EMsg_AMClientDeleteFriendsGroup", + 5563: "EMsg_AMClientDeleteFriendsGroupResponse", + 5564: "EMsg_AMClientRenameFriendsGroup", + 5565: "EMsg_AMClientRenameFriendsGroupResponse", + 5566: "EMsg_AMClientAddFriendToGroup", + 5567: "EMsg_AMClientAddFriendToGroupResponse", + 5568: "EMsg_AMClientRemoveFriendFromGroup", + 5569: "EMsg_AMClientRemoveFriendFromGroupResponse", + 5570: "EMsg_ClientAMGetPersonaNameHistory", + 5571: "EMsg_ClientAMGetPersonaNameHistoryResponse", + 5572: "EMsg_ClientRequestFreeLicense", + 5573: "EMsg_ClientRequestFreeLicenseResponse", + 5574: "EMsg_ClientDRMDownloadRequestWithCrashData", + 5575: "EMsg_ClientAuthListAck", + 5576: "EMsg_ClientItemAnnouncements", + 5577: "EMsg_ClientRequestItemAnnouncements", + 5578: "EMsg_ClientFriendMsgEchoToSender", + 5579: "EMsg_ClientChangeSteamGuardOptions", + 5580: "EMsg_ClientChangeSteamGuardOptionsResponse", + 5581: "EMsg_ClientOGSGameServerPingSample", + 5582: "EMsg_ClientCommentNotifications", + 5583: "EMsg_ClientRequestCommentNotifications", + 5584: "EMsg_ClientPersonaChangeResponse", + 5585: "EMsg_ClientRequestWebAPIAuthenticateUserNonce", + 5586: "EMsg_ClientRequestWebAPIAuthenticateUserNonceResponse", + 5587: "EMsg_ClientPlayerNicknameList", + 5588: "EMsg_AMClientSetPlayerNickname", + 5589: "EMsg_AMClientSetPlayerNicknameResponse", + 5590: "EMsg_ClientRequestOAuthTokenForApp", + 5591: "EMsg_ClientRequestOAuthTokenForAppResponse", + 5592: "EMsg_ClientGetNumberOfCurrentPlayersDP", + 5593: "EMsg_ClientGetNumberOfCurrentPlayersDPResponse", + 5594: "EMsg_ClientServiceMethod", + 5595: "EMsg_ClientServiceMethodResponse", + 5596: "EMsg_ClientFriendUserStatusPublished", + 5597: "EMsg_ClientCurrentUIMode", + 5598: "EMsg_ClientVanityURLChangedNotification", + 5599: "EMsg_ClientUserNotifications", + 5600: "EMsg_BaseDFS", + 5601: "EMsg_DFSGetFile", + 5602: "EMsg_DFSInstallLocalFile", + 5603: "EMsg_DFSConnection", + 5604: "EMsg_DFSConnectionReply", + 5605: "EMsg_ClientDFSAuthenticateRequest", + 5606: "EMsg_ClientDFSAuthenticateResponse", + 5607: "EMsg_ClientDFSEndSession", + 5608: "EMsg_DFSPurgeFile", + 5609: "EMsg_DFSRouteFile", + 5610: "EMsg_DFSGetFileFromServer", + 5611: "EMsg_DFSAcceptedResponse", + 5612: "EMsg_DFSRequestPingback", + 5613: "EMsg_DFSRecvTransmitFile", + 5614: "EMsg_DFSSendTransmitFile", + 5615: "EMsg_DFSRequestPingback2", + 5616: "EMsg_DFSResponsePingback2", + 5617: "EMsg_ClientDFSDownloadStatus", + 5618: "EMsg_DFSStartTransfer", + 5619: "EMsg_DFSTransferComplete", + 5800: "EMsg_BaseMDS", + 5801: "EMsg_ClientMDSLoginRequest", + 5802: "EMsg_ClientMDSLoginResponse", + 5803: "EMsg_ClientMDSUploadManifestRequest", + 5804: "EMsg_ClientMDSUploadManifestResponse", + 5805: "EMsg_ClientMDSTransmitManifestDataChunk", + 5806: "EMsg_ClientMDSHeartbeat", + 5807: "EMsg_ClientMDSUploadDepotChunks", + 5808: "EMsg_ClientMDSUploadDepotChunksResponse", + 5809: "EMsg_ClientMDSInitDepotBuildRequest", + 5810: "EMsg_ClientMDSInitDepotBuildResponse", + 5812: "EMsg_AMToMDSGetDepotDecryptionKey", + 5813: "EMsg_MDSToAMGetDepotDecryptionKeyResponse", + 5814: "EMsg_MDSGetVersionsForDepot", + 5815: "EMsg_MDSGetVersionsForDepotResponse", + 5816: "EMsg_MDSSetPublicVersionForDepot", + 5817: "EMsg_MDSSetPublicVersionForDepotResponse", + 5818: "EMsg_ClientMDSGetDepotManifest", + 5819: "EMsg_ClientMDSGetDepotManifestResponse", + 5820: "EMsg_ClientMDSGetDepotManifestChunk", + 5823: "EMsg_ClientMDSUploadRateTest", + 5824: "EMsg_ClientMDSUploadRateTestResponse", + 5825: "EMsg_MDSDownloadDepotChunksAck", + 5826: "EMsg_MDSContentServerStatsBroadcast", + 5827: "EMsg_MDSContentServerConfigRequest", + 5828: "EMsg_MDSContentServerConfig", + 5829: "EMsg_MDSGetDepotManifest", + 5830: "EMsg_MDSGetDepotManifestResponse", + 5831: "EMsg_MDSGetDepotManifestChunk", + 5832: "EMsg_MDSGetDepotChunk", + 5833: "EMsg_MDSGetDepotChunkResponse", + 5834: "EMsg_MDSGetDepotChunkChunk", + 5835: "EMsg_MDSUpdateContentServerConfig", + 5836: "EMsg_MDSGetServerListForUser", + 5837: "EMsg_MDSGetServerListForUserResponse", + 5838: "EMsg_ClientMDSRegisterAppBuild", + 5839: "EMsg_ClientMDSRegisterAppBuildResponse", + 5840: "EMsg_ClientMDSSetAppBuildLive", + 5841: "EMsg_ClientMDSSetAppBuildLiveResponse", + 5842: "EMsg_ClientMDSGetPrevDepotBuild", + 5843: "EMsg_ClientMDSGetPrevDepotBuildResponse", + 5844: "EMsg_MDSToCSFlushChunk", + 5845: "EMsg_ClientMDSSignInstallScript", + 5846: "EMsg_ClientMDSSignInstallScriptResponse", + 6200: "EMsg_CSBase", + 6201: "EMsg_CSPing", + 6202: "EMsg_CSPingResponse", + 6400: "EMsg_GMSBase", + 6401: "EMsg_GMSGameServerReplicate", + 6403: "EMsg_ClientGMSServerQuery", + 6404: "EMsg_GMSClientServerQueryResponse", + 6405: "EMsg_AMGMSGameServerUpdate", + 6406: "EMsg_AMGMSGameServerRemove", + 6407: "EMsg_GameServerOutOfDate", + 6501: "EMsg_ClientAuthorizeLocalDeviceRequest", + 6502: "EMsg_ClientAuthorizeLocalDevice", + 6503: "EMsg_ClientDeauthorizeDeviceRequest", + 6504: "EMsg_ClientDeauthorizeDevice", + 6505: "EMsg_ClientUseLocalDeviceAuthorizations", + 6506: "EMsg_ClientGetAuthorizedDevices", + 6507: "EMsg_ClientGetAuthorizedDevicesResponse", + 6600: "EMsg_MMSBase", + 6601: "EMsg_ClientMMSCreateLobby", + 6602: "EMsg_ClientMMSCreateLobbyResponse", + 6603: "EMsg_ClientMMSJoinLobby", + 6604: "EMsg_ClientMMSJoinLobbyResponse", + 6605: "EMsg_ClientMMSLeaveLobby", + 6606: "EMsg_ClientMMSLeaveLobbyResponse", + 6607: "EMsg_ClientMMSGetLobbyList", + 6608: "EMsg_ClientMMSGetLobbyListResponse", + 6609: "EMsg_ClientMMSSetLobbyData", + 6610: "EMsg_ClientMMSSetLobbyDataResponse", + 6611: "EMsg_ClientMMSGetLobbyData", + 6612: "EMsg_ClientMMSLobbyData", + 6613: "EMsg_ClientMMSSendLobbyChatMsg", + 6614: "EMsg_ClientMMSLobbyChatMsg", + 6615: "EMsg_ClientMMSSetLobbyOwner", + 6616: "EMsg_ClientMMSSetLobbyOwnerResponse", + 6617: "EMsg_ClientMMSSetLobbyGameServer", + 6618: "EMsg_ClientMMSLobbyGameServerSet", + 6619: "EMsg_ClientMMSUserJoinedLobby", + 6620: "EMsg_ClientMMSUserLeftLobby", + 6621: "EMsg_ClientMMSInviteToLobby", + 6622: "EMsg_ClientMMSFlushFrenemyListCache", + 6623: "EMsg_ClientMMSFlushFrenemyListCacheResponse", + 6624: "EMsg_ClientMMSSetLobbyLinked", + 6800: "EMsg_NonStdMsgBase", + 6801: "EMsg_NonStdMsgMemcached", + 6802: "EMsg_NonStdMsgHTTPServer", + 6803: "EMsg_NonStdMsgHTTPClient", + 6804: "EMsg_NonStdMsgWGResponse", + 6805: "EMsg_NonStdMsgPHPSimulator", + 6806: "EMsg_NonStdMsgChase", + 6807: "EMsg_NonStdMsgDFSTransfer", + 6808: "EMsg_NonStdMsgTests", + 6809: "EMsg_NonStdMsgUMQpipeAAPL", + 6810: "EMsg_NonStdMsgSyslog", + 6811: "EMsg_NonStdMsgLogsink", + 7000: "EMsg_UDSBase", + 7001: "EMsg_ClientUDSP2PSessionStarted", + 7002: "EMsg_ClientUDSP2PSessionEnded", + 7003: "EMsg_UDSRenderUserAuth", + 7004: "EMsg_UDSRenderUserAuthResponse", + 7005: "EMsg_ClientUDSInviteToGame", + 7006: "EMsg_UDSFindSession", + 7007: "EMsg_UDSFindSessionResponse", + 7100: "EMsg_MPASBase", + 7101: "EMsg_MPASVacBanReset", + 7200: "EMsg_KGSBase", + 7201: "EMsg_KGSAllocateKeyRange", + 7202: "EMsg_KGSAllocateKeyRangeResponse", + 7203: "EMsg_KGSGenerateKeys", + 7204: "EMsg_KGSGenerateKeysResponse", + 7205: "EMsg_KGSRemapKeys", + 7206: "EMsg_KGSRemapKeysResponse", + 7207: "EMsg_KGSGenerateGameStopWCKeys", + 7208: "EMsg_KGSGenerateGameStopWCKeysResponse", + 7300: "EMsg_UCMBase", + 7301: "EMsg_ClientUCMAddScreenshot", + 7302: "EMsg_ClientUCMAddScreenshotResponse", + 7303: "EMsg_UCMValidateObjectExists", + 7304: "EMsg_UCMValidateObjectExistsResponse", + 7307: "EMsg_UCMResetCommunityContent", + 7308: "EMsg_UCMResetCommunityContentResponse", + 7309: "EMsg_ClientUCMDeleteScreenshot", + 7310: "EMsg_ClientUCMDeleteScreenshotResponse", + 7311: "EMsg_ClientUCMPublishFile", + 7312: "EMsg_ClientUCMPublishFileResponse", + 7313: "EMsg_ClientUCMGetPublishedFileDetails", + 7314: "EMsg_ClientUCMGetPublishedFileDetailsResponse", + 7315: "EMsg_ClientUCMDeletePublishedFile", + 7316: "EMsg_ClientUCMDeletePublishedFileResponse", + 7317: "EMsg_ClientUCMEnumerateUserPublishedFiles", + 7318: "EMsg_ClientUCMEnumerateUserPublishedFilesResponse", + 7319: "EMsg_ClientUCMSubscribePublishedFile", + 7320: "EMsg_ClientUCMSubscribePublishedFileResponse", + 7321: "EMsg_ClientUCMEnumerateUserSubscribedFiles", + 7322: "EMsg_ClientUCMEnumerateUserSubscribedFilesResponse", + 7323: "EMsg_ClientUCMUnsubscribePublishedFile", + 7324: "EMsg_ClientUCMUnsubscribePublishedFileResponse", + 7325: "EMsg_ClientUCMUpdatePublishedFile", + 7326: "EMsg_ClientUCMUpdatePublishedFileResponse", + 7327: "EMsg_UCMUpdatePublishedFile", + 7328: "EMsg_UCMUpdatePublishedFileResponse", + 7329: "EMsg_UCMDeletePublishedFile", + 7330: "EMsg_UCMDeletePublishedFileResponse", + 7331: "EMsg_UCMUpdatePublishedFileStat", + 7332: "EMsg_UCMUpdatePublishedFileBan", + 7333: "EMsg_UCMUpdatePublishedFileBanResponse", + 7334: "EMsg_UCMUpdateTaggedScreenshot", + 7335: "EMsg_UCMAddTaggedScreenshot", + 7336: "EMsg_UCMRemoveTaggedScreenshot", + 7337: "EMsg_UCMReloadPublishedFile", + 7338: "EMsg_UCMReloadUserFileListCaches", + 7339: "EMsg_UCMPublishedFileReported", + 7340: "EMsg_UCMUpdatePublishedFileIncompatibleStatus", + 7341: "EMsg_UCMPublishedFilePreviewAdd", + 7342: "EMsg_UCMPublishedFilePreviewAddResponse", + 7343: "EMsg_UCMPublishedFilePreviewRemove", + 7344: "EMsg_UCMPublishedFilePreviewRemoveResponse", + 7345: "EMsg_UCMPublishedFilePreviewChangeSortOrder", + 7346: "EMsg_UCMPublishedFilePreviewChangeSortOrderResponse", + 7347: "EMsg_ClientUCMPublishedFileSubscribed", + 7348: "EMsg_ClientUCMPublishedFileUnsubscribed", + 7349: "EMsg_UCMPublishedFileSubscribed", + 7350: "EMsg_UCMPublishedFileUnsubscribed", + 7351: "EMsg_UCMPublishFile", + 7352: "EMsg_UCMPublishFileResponse", + 7353: "EMsg_UCMPublishedFileChildAdd", + 7354: "EMsg_UCMPublishedFileChildAddResponse", + 7355: "EMsg_UCMPublishedFileChildRemove", + 7356: "EMsg_UCMPublishedFileChildRemoveResponse", + 7357: "EMsg_UCMPublishedFileChildChangeSortOrder", + 7358: "EMsg_UCMPublishedFileChildChangeSortOrderResponse", + 7359: "EMsg_UCMPublishedFileParentChanged", + 7360: "EMsg_ClientUCMGetPublishedFilesForUser", + 7361: "EMsg_ClientUCMGetPublishedFilesForUserResponse", + 7362: "EMsg_UCMGetPublishedFilesForUser", + 7363: "EMsg_UCMGetPublishedFilesForUserResponse", + 7364: "EMsg_ClientUCMSetUserPublishedFileAction", + 7365: "EMsg_ClientUCMSetUserPublishedFileActionResponse", + 7366: "EMsg_ClientUCMEnumeratePublishedFilesByUserAction", + 7367: "EMsg_ClientUCMEnumeratePublishedFilesByUserActionResponse", + 7368: "EMsg_ClientUCMPublishedFileDeleted", + 7369: "EMsg_UCMGetUserSubscribedFiles", + 7370: "EMsg_UCMGetUserSubscribedFilesResponse", + 7371: "EMsg_UCMFixStatsPublishedFile", + 7372: "EMsg_UCMDeleteOldScreenshot", + 7373: "EMsg_UCMDeleteOldScreenshotResponse", + 7374: "EMsg_UCMDeleteOldVideo", + 7375: "EMsg_UCMDeleteOldVideoResponse", + 7376: "EMsg_UCMUpdateOldScreenshotPrivacy", + 7377: "EMsg_UCMUpdateOldScreenshotPrivacyResponse", + 7378: "EMsg_ClientUCMEnumerateUserSubscribedFilesWithUpdates", + 7379: "EMsg_ClientUCMEnumerateUserSubscribedFilesWithUpdatesResponse", + 7380: "EMsg_UCMPublishedFileContentUpdated", + 7381: "EMsg_UCMPublishedFileUpdated", + 7382: "EMsg_ClientWorkshopItemChangesRequest", + 7383: "EMsg_ClientWorkshopItemChangesResponse", + 7384: "EMsg_ClientWorkshopItemInfoRequest", + 7385: "EMsg_ClientWorkshopItemInfoResponse", + 7500: "EMsg_FSBase", + 7501: "EMsg_ClientRichPresenceUpload", + 7502: "EMsg_ClientRichPresenceRequest", + 7503: "EMsg_ClientRichPresenceInfo", + 7504: "EMsg_FSRichPresenceRequest", + 7505: "EMsg_FSRichPresenceResponse", + 7506: "EMsg_FSComputeFrenematrix", + 7507: "EMsg_FSComputeFrenematrixResponse", + 7508: "EMsg_FSPlayStatusNotification", + 7509: "EMsg_FSPublishPersonaStatus", + 7510: "EMsg_FSAddOrRemoveFollower", + 7511: "EMsg_FSAddOrRemoveFollowerResponse", + 7512: "EMsg_FSUpdateFollowingList", + 7513: "EMsg_FSCommentNotification", + 7514: "EMsg_FSCommentNotificationViewed", + 7515: "EMsg_ClientFSGetFollowerCount", + 7516: "EMsg_ClientFSGetFollowerCountResponse", + 7517: "EMsg_ClientFSGetIsFollowing", + 7518: "EMsg_ClientFSGetIsFollowingResponse", + 7519: "EMsg_ClientFSEnumerateFollowingList", + 7520: "EMsg_ClientFSEnumerateFollowingListResponse", + 7521: "EMsg_FSGetPendingNotificationCount", + 7522: "EMsg_FSGetPendingNotificationCountResponse", + 7523: "EMsg_ClientFSOfflineMessageNotification", + 7524: "EMsg_ClientFSRequestOfflineMessageCount", + 7525: "EMsg_ClientFSGetFriendMessageHistory", + 7526: "EMsg_ClientFSGetFriendMessageHistoryResponse", + 7527: "EMsg_ClientFSGetFriendMessageHistoryForOfflineMessages", + 7528: "EMsg_ClientFSGetFriendsSteamLevels", + 7529: "EMsg_ClientFSGetFriendsSteamLevelsResponse", + 7600: "EMsg_DRMRange2", + 7601: "EMsg_CEGVersionSetEnableDisableResponse", + 7602: "EMsg_CEGPropStatusDRMSRequest", + 7603: "EMsg_CEGPropStatusDRMSResponse", + 7604: "EMsg_CEGWhackFailureReportRequest", + 7605: "EMsg_CEGWhackFailureReportResponse", + 7606: "EMsg_DRMSFetchVersionSet", + 7607: "EMsg_DRMSFetchVersionSetResponse", + 7700: "EMsg_EconBase", + 7701: "EMsg_EconTrading_InitiateTradeRequest", + 7702: "EMsg_EconTrading_InitiateTradeProposed", + 7703: "EMsg_EconTrading_InitiateTradeResponse", + 7704: "EMsg_EconTrading_InitiateTradeResult", + 7705: "EMsg_EconTrading_StartSession", + 7706: "EMsg_EconTrading_CancelTradeRequest", + 7707: "EMsg_EconFlushInventoryCache", + 7708: "EMsg_EconFlushInventoryCacheResponse", + 7711: "EMsg_EconCDKeyProcessTransaction", + 7712: "EMsg_EconCDKeyProcessTransactionResponse", + 7713: "EMsg_EconGetErrorLogs", + 7714: "EMsg_EconGetErrorLogsResponse", + 7800: "EMsg_RMRange", + 7801: "EMsg_RMTestVerisignOTPResponse", + 7803: "EMsg_RMDeleteMemcachedKeys", + 7804: "EMsg_RMRemoteInvoke", + 7805: "EMsg_BadLoginIPList", + 7900: "EMsg_UGSBase", + 7901: "EMsg_ClientUGSGetGlobalStats", + 7902: "EMsg_ClientUGSGetGlobalStatsResponse", + 8000: "EMsg_StoreBase", + 8100: "EMsg_UMQBase", + 8101: "EMsg_UMQLogonResponse", + 8102: "EMsg_UMQLogoffRequest", + 8103: "EMsg_UMQLogoffResponse", + 8104: "EMsg_UMQSendChatMessage", + 8105: "EMsg_UMQIncomingChatMessage", + 8106: "EMsg_UMQPoll", + 8107: "EMsg_UMQPollResults", + 8108: "EMsg_UMQ2AM_ClientMsgBatch", + 8109: "EMsg_UMQEnqueueMobileSalePromotions", + 8110: "EMsg_UMQEnqueueMobileAnnouncements", + 8200: "EMsg_WorkshopBase", + 8201: "EMsg_WorkshopAcceptTOSResponse", + 8300: "EMsg_WebAPIBase", + 8301: "EMsg_WebAPIValidateOAuth2TokenResponse", + 8302: "EMsg_WebAPIInvalidateTokensForAccount", + 8303: "EMsg_WebAPIRegisterGCInterfaces", + 8304: "EMsg_WebAPIInvalidateOAuthClientCache", + 8305: "EMsg_WebAPIInvalidateOAuthTokenCache", + 8400: "EMsg_BackpackBase", + 8401: "EMsg_BackpackAddToCurrency", + 8402: "EMsg_BackpackAddToCurrencyResponse", + 8500: "EMsg_CREBase", + 8501: "EMsg_CRERankByTrend", + 8502: "EMsg_CRERankByTrendResponse", + 8503: "EMsg_CREItemVoteSummary", + 8504: "EMsg_CREItemVoteSummaryResponse", + 8505: "EMsg_CRERankByVote", + 8506: "EMsg_CRERankByVoteResponse", + 8507: "EMsg_CREUpdateUserPublishedItemVote", + 8508: "EMsg_CREUpdateUserPublishedItemVoteResponse", + 8509: "EMsg_CREGetUserPublishedItemVoteDetails", + 8510: "EMsg_CREGetUserPublishedItemVoteDetailsResponse", + 8511: "EMsg_CREEnumeratePublishedFiles", + 8512: "EMsg_CREEnumeratePublishedFilesResponse", + 8513: "EMsg_CREPublishedFileVoteAdded", + 8600: "EMsg_SecretsBase", + 8601: "EMsg_SecretsCredentialPairResponse", + 8602: "EMsg_SecretsRequestServerIdentity", + 8603: "EMsg_SecretsServerIdentityResponse", + 8604: "EMsg_SecretsUpdateServerIdentities", + 8700: "EMsg_BoxMonitorBase", + 8701: "EMsg_BoxMonitorReportResponse", + 8800: "EMsg_LogsinkBase", + 8900: "EMsg_PICSBase", + 8901: "EMsg_ClientPICSChangesSinceRequest", + 8902: "EMsg_ClientPICSChangesSinceResponse", + 8903: "EMsg_ClientPICSProductInfoRequest", + 8904: "EMsg_ClientPICSProductInfoResponse", + 8905: "EMsg_ClientPICSAccessTokenRequest", + 8906: "EMsg_ClientPICSAccessTokenResponse", + 9000: "EMsg_WorkerProcess", + 9001: "EMsg_WorkerProcessPingResponse", + 9002: "EMsg_WorkerProcessShutdown", + 9100: "EMsg_DRMWorkerProcess", + 9101: "EMsg_DRMWorkerProcessDRMAndSignResponse", + 9102: "EMsg_DRMWorkerProcessSteamworksInfoRequest", + 9103: "EMsg_DRMWorkerProcessSteamworksInfoResponse", + 9104: "EMsg_DRMWorkerProcessInstallDRMDLLRequest", + 9105: "EMsg_DRMWorkerProcessInstallDRMDLLResponse", + 9106: "EMsg_DRMWorkerProcessSecretIdStringRequest", + 9107: "EMsg_DRMWorkerProcessSecretIdStringResponse", + 9108: "EMsg_DRMWorkerProcessGetDRMGuidsFromFileRequest", + 9109: "EMsg_DRMWorkerProcessGetDRMGuidsFromFileResponse", + 9110: "EMsg_DRMWorkerProcessInstallProcessedFilesRequest", + 9111: "EMsg_DRMWorkerProcessInstallProcessedFilesResponse", + 9112: "EMsg_DRMWorkerProcessExamineBlobRequest", + 9113: "EMsg_DRMWorkerProcessExamineBlobResponse", + 9114: "EMsg_DRMWorkerProcessDescribeSecretRequest", + 9115: "EMsg_DRMWorkerProcessDescribeSecretResponse", + 9116: "EMsg_DRMWorkerProcessBackfillOriginalRequest", + 9117: "EMsg_DRMWorkerProcessBackfillOriginalResponse", + 9118: "EMsg_DRMWorkerProcessValidateDRMDLLRequest", + 9119: "EMsg_DRMWorkerProcessValidateDRMDLLResponse", + 9120: "EMsg_DRMWorkerProcessValidateFileRequest", + 9121: "EMsg_DRMWorkerProcessValidateFileResponse", + 9122: "EMsg_DRMWorkerProcessSplitAndInstallRequest", + 9123: "EMsg_DRMWorkerProcessSplitAndInstallResponse", + 9124: "EMsg_DRMWorkerProcessGetBlobRequest", + 9125: "EMsg_DRMWorkerProcessGetBlobResponse", + 9126: "EMsg_DRMWorkerProcessEvaluateCrashRequest", + 9127: "EMsg_DRMWorkerProcessEvaluateCrashResponse", + 9128: "EMsg_DRMWorkerProcessAnalyzeFileRequest", + 9129: "EMsg_DRMWorkerProcessAnalyzeFileResponse", + 9130: "EMsg_DRMWorkerProcessUnpackBlobRequest", + 9131: "EMsg_DRMWorkerProcessUnpackBlobResponse", + 9132: "EMsg_DRMWorkerProcessInstallAllRequest", + 9133: "EMsg_DRMWorkerProcessInstallAllResponse", + 9200: "EMsg_TestWorkerProcess", + 9201: "EMsg_TestWorkerProcessLoadUnloadModuleResponse", + 9202: "EMsg_TestWorkerProcessServiceModuleCallRequest", + 9203: "EMsg_TestWorkerProcessServiceModuleCallResponse", + 9330: "EMsg_ClientGetEmoticonList", + 9331: "EMsg_ClientEmoticonList", + 9400: "EMsg_ClientSharedLibraryBase", + 9403: "EMsg_ClientSharedLicensesLockStatus", + 9404: "EMsg_ClientSharedLicensesStopPlaying", + 9405: "EMsg_ClientSharedLibraryLockStatus", + 9406: "EMsg_ClientSharedLibraryStopPlaying", + 9507: "EMsg_ClientUnlockStreaming", + 9508: "EMsg_ClientUnlockStreamingResponse", + 9600: "EMsg_ClientPlayingSessionState", + 9601: "EMsg_ClientKickPlayingSession", + 9700: "EMsg_ClientBroadcastInit", + 9701: "EMsg_ClientBroadcastFrames", + 9702: "EMsg_ClientBroadcastDisconnect", + 9703: "EMsg_ClientBroadcastScreenshot", + 9704: "EMsg_ClientBroadcastUploadConfig", + 9800: "EMsg_ClientVoiceCallPreAuthorize", + 9801: "EMsg_ClientVoiceCallPreAuthorizeResponse", +} + +func (e EMsg) String() string { + if s, ok := EMsg_name[e]; ok { + return s + } + var flags []string + for k, v := range EMsg_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EResult int32 + +const ( + EResult_Invalid EResult = 0 + EResult_OK EResult = 1 + EResult_Fail EResult = 2 + EResult_NoConnection EResult = 3 + EResult_InvalidPassword EResult = 5 + EResult_LoggedInElsewhere EResult = 6 + EResult_InvalidProtocolVer EResult = 7 + EResult_InvalidParam EResult = 8 + EResult_FileNotFound EResult = 9 + EResult_Busy EResult = 10 + EResult_InvalidState EResult = 11 + EResult_InvalidName EResult = 12 + EResult_InvalidEmail EResult = 13 + EResult_DuplicateName EResult = 14 + EResult_AccessDenied EResult = 15 + EResult_Timeout EResult = 16 + EResult_Banned EResult = 17 + EResult_AccountNotFound EResult = 18 + EResult_InvalidSteamID EResult = 19 + EResult_ServiceUnavailable EResult = 20 + EResult_NotLoggedOn EResult = 21 + EResult_Pending EResult = 22 + EResult_EncryptionFailure EResult = 23 + EResult_InsufficientPrivilege EResult = 24 + EResult_LimitExceeded EResult = 25 + EResult_Revoked EResult = 26 + EResult_Expired EResult = 27 + EResult_AlreadyRedeemed EResult = 28 + EResult_DuplicateRequest EResult = 29 + EResult_AlreadyOwned EResult = 30 + EResult_IPNotFound EResult = 31 + EResult_PersistFailed EResult = 32 + EResult_LockingFailed EResult = 33 + EResult_LogonSessionReplaced EResult = 34 + EResult_ConnectFailed EResult = 35 + EResult_HandshakeFailed EResult = 36 + EResult_IOFailure EResult = 37 + EResult_RemoteDisconnect EResult = 38 + EResult_ShoppingCartNotFound EResult = 39 + EResult_Blocked EResult = 40 + EResult_Ignored EResult = 41 + EResult_NoMatch EResult = 42 + EResult_AccountDisabled EResult = 43 + EResult_ServiceReadOnly EResult = 44 + EResult_AccountNotFeatured EResult = 45 + EResult_AdministratorOK EResult = 46 + EResult_ContentVersion EResult = 47 + EResult_TryAnotherCM EResult = 48 + EResult_PasswordRequiredToKickSession EResult = 49 + EResult_AlreadyLoggedInElsewhere EResult = 50 + EResult_Suspended EResult = 51 + EResult_Cancelled EResult = 52 + EResult_DataCorruption EResult = 53 + EResult_DiskFull EResult = 54 + EResult_RemoteCallFailed EResult = 55 + EResult_PasswordNotSet EResult = 56 // Deprecated: renamed to PasswordUnset + EResult_PasswordUnset EResult = 56 + EResult_ExternalAccountUnlinked EResult = 57 + EResult_PSNTicketInvalid EResult = 58 + EResult_ExternalAccountAlreadyLinked EResult = 59 + EResult_RemoteFileConflict EResult = 60 + EResult_IllegalPassword EResult = 61 + EResult_SameAsPreviousValue EResult = 62 + EResult_AccountLogonDenied EResult = 63 + EResult_CannotUseOldPassword EResult = 64 + EResult_InvalidLoginAuthCode EResult = 65 + EResult_AccountLogonDeniedNoMailSent EResult = 66 // Deprecated: renamed to AccountLogonDeniedNoMail + EResult_AccountLogonDeniedNoMail EResult = 66 + EResult_HardwareNotCapableOfIPT EResult = 67 + EResult_IPTInitError EResult = 68 + EResult_ParentalControlRestricted EResult = 69 + EResult_FacebookQueryError EResult = 70 + EResult_ExpiredLoginAuthCode EResult = 71 + EResult_IPLoginRestrictionFailed EResult = 72 + EResult_AccountLocked EResult = 73 // Deprecated: renamed to AccountLockedDown + EResult_AccountLockedDown EResult = 73 + EResult_AccountLogonDeniedVerifiedEmailRequired EResult = 74 + EResult_NoMatchingURL EResult = 75 + EResult_BadResponse EResult = 76 + EResult_RequirePasswordReEntry EResult = 77 + EResult_ValueOutOfRange EResult = 78 + EResult_UnexpectedError EResult = 79 + EResult_Disabled EResult = 80 + EResult_InvalidCEGSubmission EResult = 81 + EResult_RestrictedDevice EResult = 82 + EResult_RegionLocked EResult = 83 + EResult_RateLimitExceeded EResult = 84 + EResult_AccountLogonDeniedNeedTwoFactorCode EResult = 85 // Deprecated: renamed to AccountLoginDeniedNeedTwoFactor + EResult_AccountLoginDeniedNeedTwoFactor EResult = 85 + EResult_ItemOrEntryHasBeenDeleted EResult = 86 // Deprecated: renamed to ItemDeleted + EResult_ItemDeleted EResult = 86 + EResult_AccountLoginDeniedThrottle EResult = 87 + EResult_TwoFactorCodeMismatch EResult = 88 + EResult_TwoFactorActivationCodeMismatch EResult = 89 + EResult_AccountAssociatedToMultiplePlayers EResult = 90 // Deprecated: renamed to AccountAssociatedToMultiplePartners + EResult_AccountAssociatedToMultiplePartners EResult = 90 + EResult_NotModified EResult = 91 + EResult_NoMobileDeviceAvailable EResult = 92 // Deprecated: renamed to NoMobileDevice + EResult_NoMobileDevice EResult = 92 + EResult_TimeIsOutOfSync EResult = 93 // Deprecated: renamed to TimeNotSynced + EResult_TimeNotSynced EResult = 93 + EResult_SMSCodeFailed EResult = 94 + EResult_TooManyAccountsAccessThisResource EResult = 95 // Deprecated: renamed to AccountLimitExceeded + EResult_AccountLimitExceeded EResult = 95 + EResult_AccountActivityLimitExceeded EResult = 96 + EResult_PhoneActivityLimitExceeded EResult = 97 + EResult_RefundToWallet EResult = 98 + EResult_EmailSendFailure EResult = 99 + EResult_NotSettled EResult = 100 + EResult_NeedCaptcha EResult = 101 +) + +var EResult_name = map[EResult]string{ + 0: "EResult_Invalid", + 1: "EResult_OK", + 2: "EResult_Fail", + 3: "EResult_NoConnection", + 5: "EResult_InvalidPassword", + 6: "EResult_LoggedInElsewhere", + 7: "EResult_InvalidProtocolVer", + 8: "EResult_InvalidParam", + 9: "EResult_FileNotFound", + 10: "EResult_Busy", + 11: "EResult_InvalidState", + 12: "EResult_InvalidName", + 13: "EResult_InvalidEmail", + 14: "EResult_DuplicateName", + 15: "EResult_AccessDenied", + 16: "EResult_Timeout", + 17: "EResult_Banned", + 18: "EResult_AccountNotFound", + 19: "EResult_InvalidSteamID", + 20: "EResult_ServiceUnavailable", + 21: "EResult_NotLoggedOn", + 22: "EResult_Pending", + 23: "EResult_EncryptionFailure", + 24: "EResult_InsufficientPrivilege", + 25: "EResult_LimitExceeded", + 26: "EResult_Revoked", + 27: "EResult_Expired", + 28: "EResult_AlreadyRedeemed", + 29: "EResult_DuplicateRequest", + 30: "EResult_AlreadyOwned", + 31: "EResult_IPNotFound", + 32: "EResult_PersistFailed", + 33: "EResult_LockingFailed", + 34: "EResult_LogonSessionReplaced", + 35: "EResult_ConnectFailed", + 36: "EResult_HandshakeFailed", + 37: "EResult_IOFailure", + 38: "EResult_RemoteDisconnect", + 39: "EResult_ShoppingCartNotFound", + 40: "EResult_Blocked", + 41: "EResult_Ignored", + 42: "EResult_NoMatch", + 43: "EResult_AccountDisabled", + 44: "EResult_ServiceReadOnly", + 45: "EResult_AccountNotFeatured", + 46: "EResult_AdministratorOK", + 47: "EResult_ContentVersion", + 48: "EResult_TryAnotherCM", + 49: "EResult_PasswordRequiredToKickSession", + 50: "EResult_AlreadyLoggedInElsewhere", + 51: "EResult_Suspended", + 52: "EResult_Cancelled", + 53: "EResult_DataCorruption", + 54: "EResult_DiskFull", + 55: "EResult_RemoteCallFailed", + 56: "EResult_PasswordNotSet", + 57: "EResult_ExternalAccountUnlinked", + 58: "EResult_PSNTicketInvalid", + 59: "EResult_ExternalAccountAlreadyLinked", + 60: "EResult_RemoteFileConflict", + 61: "EResult_IllegalPassword", + 62: "EResult_SameAsPreviousValue", + 63: "EResult_AccountLogonDenied", + 64: "EResult_CannotUseOldPassword", + 65: "EResult_InvalidLoginAuthCode", + 66: "EResult_AccountLogonDeniedNoMailSent", + 67: "EResult_HardwareNotCapableOfIPT", + 68: "EResult_IPTInitError", + 69: "EResult_ParentalControlRestricted", + 70: "EResult_FacebookQueryError", + 71: "EResult_ExpiredLoginAuthCode", + 72: "EResult_IPLoginRestrictionFailed", + 73: "EResult_AccountLocked", + 74: "EResult_AccountLogonDeniedVerifiedEmailRequired", + 75: "EResult_NoMatchingURL", + 76: "EResult_BadResponse", + 77: "EResult_RequirePasswordReEntry", + 78: "EResult_ValueOutOfRange", + 79: "EResult_UnexpectedError", + 80: "EResult_Disabled", + 81: "EResult_InvalidCEGSubmission", + 82: "EResult_RestrictedDevice", + 83: "EResult_RegionLocked", + 84: "EResult_RateLimitExceeded", + 85: "EResult_AccountLogonDeniedNeedTwoFactorCode", + 86: "EResult_ItemOrEntryHasBeenDeleted", + 87: "EResult_AccountLoginDeniedThrottle", + 88: "EResult_TwoFactorCodeMismatch", + 89: "EResult_TwoFactorActivationCodeMismatch", + 90: "EResult_AccountAssociatedToMultiplePlayers", + 91: "EResult_NotModified", + 92: "EResult_NoMobileDeviceAvailable", + 93: "EResult_TimeIsOutOfSync", + 94: "EResult_SMSCodeFailed", + 95: "EResult_TooManyAccountsAccessThisResource", + 96: "EResult_AccountActivityLimitExceeded", + 97: "EResult_PhoneActivityLimitExceeded", + 98: "EResult_RefundToWallet", + 99: "EResult_EmailSendFailure", + 100: "EResult_NotSettled", + 101: "EResult_NeedCaptcha", +} + +func (e EResult) String() string { + if s, ok := EResult_name[e]; ok { + return s + } + var flags []string + for k, v := range EResult_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EUniverse int32 + +const ( + EUniverse_Invalid EUniverse = 0 + EUniverse_Public EUniverse = 1 + EUniverse_Beta EUniverse = 2 + EUniverse_Internal EUniverse = 3 + EUniverse_Dev EUniverse = 4 + EUniverse_Max EUniverse = 5 +) + +var EUniverse_name = map[EUniverse]string{ + 0: "EUniverse_Invalid", + 1: "EUniverse_Public", + 2: "EUniverse_Beta", + 3: "EUniverse_Internal", + 4: "EUniverse_Dev", + 5: "EUniverse_Max", +} + +func (e EUniverse) String() string { + if s, ok := EUniverse_name[e]; ok { + return s + } + var flags []string + for k, v := range EUniverse_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatEntryType int32 + +const ( + EChatEntryType_Invalid EChatEntryType = 0 + EChatEntryType_ChatMsg EChatEntryType = 1 + EChatEntryType_Typing EChatEntryType = 2 + EChatEntryType_InviteGame EChatEntryType = 3 + EChatEntryType_Emote EChatEntryType = 4 // Deprecated: No longer supported by clients + EChatEntryType_LobbyGameStart EChatEntryType = 5 // Deprecated: Listen for LobbyGameCreated_t callback instead + EChatEntryType_LeftConversation EChatEntryType = 6 + EChatEntryType_Entered EChatEntryType = 7 + EChatEntryType_WasKicked EChatEntryType = 8 + EChatEntryType_WasBanned EChatEntryType = 9 + EChatEntryType_Disconnected EChatEntryType = 10 + EChatEntryType_HistoricalChat EChatEntryType = 11 + EChatEntryType_Reserved1 EChatEntryType = 12 + EChatEntryType_Reserved2 EChatEntryType = 13 + EChatEntryType_LinkBlocked EChatEntryType = 14 +) + +var EChatEntryType_name = map[EChatEntryType]string{ + 0: "EChatEntryType_Invalid", + 1: "EChatEntryType_ChatMsg", + 2: "EChatEntryType_Typing", + 3: "EChatEntryType_InviteGame", + 4: "EChatEntryType_Emote", + 5: "EChatEntryType_LobbyGameStart", + 6: "EChatEntryType_LeftConversation", + 7: "EChatEntryType_Entered", + 8: "EChatEntryType_WasKicked", + 9: "EChatEntryType_WasBanned", + 10: "EChatEntryType_Disconnected", + 11: "EChatEntryType_HistoricalChat", + 12: "EChatEntryType_Reserved1", + 13: "EChatEntryType_Reserved2", + 14: "EChatEntryType_LinkBlocked", +} + +func (e EChatEntryType) String() string { + if s, ok := EChatEntryType_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatEntryType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EPersonaState int32 + +const ( + EPersonaState_Offline EPersonaState = 0 + EPersonaState_Online EPersonaState = 1 + EPersonaState_Busy EPersonaState = 2 + EPersonaState_Away EPersonaState = 3 + EPersonaState_Snooze EPersonaState = 4 + EPersonaState_LookingToTrade EPersonaState = 5 + EPersonaState_LookingToPlay EPersonaState = 6 + EPersonaState_Max EPersonaState = 7 +) + +var EPersonaState_name = map[EPersonaState]string{ + 0: "EPersonaState_Offline", + 1: "EPersonaState_Online", + 2: "EPersonaState_Busy", + 3: "EPersonaState_Away", + 4: "EPersonaState_Snooze", + 5: "EPersonaState_LookingToTrade", + 6: "EPersonaState_LookingToPlay", + 7: "EPersonaState_Max", +} + +func (e EPersonaState) String() string { + if s, ok := EPersonaState_name[e]; ok { + return s + } + var flags []string + for k, v := range EPersonaState_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EAccountType int32 + +const ( + EAccountType_Invalid EAccountType = 0 + EAccountType_Individual EAccountType = 1 + EAccountType_Multiseat EAccountType = 2 + EAccountType_GameServer EAccountType = 3 + EAccountType_AnonGameServer EAccountType = 4 + EAccountType_Pending EAccountType = 5 + EAccountType_ContentServer EAccountType = 6 + EAccountType_Clan EAccountType = 7 + EAccountType_Chat EAccountType = 8 + EAccountType_ConsoleUser EAccountType = 9 + EAccountType_AnonUser EAccountType = 10 + EAccountType_Max EAccountType = 11 +) + +var EAccountType_name = map[EAccountType]string{ + 0: "EAccountType_Invalid", + 1: "EAccountType_Individual", + 2: "EAccountType_Multiseat", + 3: "EAccountType_GameServer", + 4: "EAccountType_AnonGameServer", + 5: "EAccountType_Pending", + 6: "EAccountType_ContentServer", + 7: "EAccountType_Clan", + 8: "EAccountType_Chat", + 9: "EAccountType_ConsoleUser", + 10: "EAccountType_AnonUser", + 11: "EAccountType_Max", +} + +func (e EAccountType) String() string { + if s, ok := EAccountType_name[e]; ok { + return s + } + var flags []string + for k, v := range EAccountType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EFriendRelationship int32 + +const ( + EFriendRelationship_None EFriendRelationship = 0 + EFriendRelationship_Blocked EFriendRelationship = 1 + EFriendRelationship_RequestRecipient EFriendRelationship = 2 + EFriendRelationship_Friend EFriendRelationship = 3 + EFriendRelationship_RequestInitiator EFriendRelationship = 4 + EFriendRelationship_Ignored EFriendRelationship = 5 + EFriendRelationship_IgnoredFriend EFriendRelationship = 6 + EFriendRelationship_SuggestedFriend EFriendRelationship = 7 + EFriendRelationship_Max EFriendRelationship = 8 +) + +var EFriendRelationship_name = map[EFriendRelationship]string{ + 0: "EFriendRelationship_None", + 1: "EFriendRelationship_Blocked", + 2: "EFriendRelationship_RequestRecipient", + 3: "EFriendRelationship_Friend", + 4: "EFriendRelationship_RequestInitiator", + 5: "EFriendRelationship_Ignored", + 6: "EFriendRelationship_IgnoredFriend", + 7: "EFriendRelationship_SuggestedFriend", + 8: "EFriendRelationship_Max", +} + +func (e EFriendRelationship) String() string { + if s, ok := EFriendRelationship_name[e]; ok { + return s + } + var flags []string + for k, v := range EFriendRelationship_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EAccountFlags int32 + +const ( + EAccountFlags_NormalUser EAccountFlags = 0 + EAccountFlags_PersonaNameSet EAccountFlags = 1 + EAccountFlags_Unbannable EAccountFlags = 2 + EAccountFlags_PasswordSet EAccountFlags = 4 + EAccountFlags_Support EAccountFlags = 8 + EAccountFlags_Admin EAccountFlags = 16 + EAccountFlags_Supervisor EAccountFlags = 32 + EAccountFlags_AppEditor EAccountFlags = 64 + EAccountFlags_HWIDSet EAccountFlags = 128 + EAccountFlags_PersonalQASet EAccountFlags = 256 + EAccountFlags_VacBeta EAccountFlags = 512 + EAccountFlags_Debug EAccountFlags = 1024 + EAccountFlags_Disabled EAccountFlags = 2048 + EAccountFlags_LimitedUser EAccountFlags = 4096 + EAccountFlags_LimitedUserForce EAccountFlags = 8192 + EAccountFlags_EmailValidated EAccountFlags = 16384 + EAccountFlags_MarketingTreatment EAccountFlags = 32768 + EAccountFlags_OGGInviteOptOut EAccountFlags = 65536 + EAccountFlags_ForcePasswordChange EAccountFlags = 131072 + EAccountFlags_ForceEmailVerification EAccountFlags = 262144 + EAccountFlags_LogonExtraSecurity EAccountFlags = 524288 + EAccountFlags_LogonExtraSecurityDisabled EAccountFlags = 1048576 + EAccountFlags_Steam2MigrationComplete EAccountFlags = 2097152 + EAccountFlags_NeedLogs EAccountFlags = 4194304 + EAccountFlags_Lockdown EAccountFlags = 8388608 + EAccountFlags_MasterAppEditor EAccountFlags = 16777216 + EAccountFlags_BannedFromWebAPI EAccountFlags = 33554432 + EAccountFlags_ClansOnlyFromFriends EAccountFlags = 67108864 + EAccountFlags_GlobalModerator EAccountFlags = 134217728 +) + +var EAccountFlags_name = map[EAccountFlags]string{ + 0: "EAccountFlags_NormalUser", + 1: "EAccountFlags_PersonaNameSet", + 2: "EAccountFlags_Unbannable", + 4: "EAccountFlags_PasswordSet", + 8: "EAccountFlags_Support", + 16: "EAccountFlags_Admin", + 32: "EAccountFlags_Supervisor", + 64: "EAccountFlags_AppEditor", + 128: "EAccountFlags_HWIDSet", + 256: "EAccountFlags_PersonalQASet", + 512: "EAccountFlags_VacBeta", + 1024: "EAccountFlags_Debug", + 2048: "EAccountFlags_Disabled", + 4096: "EAccountFlags_LimitedUser", + 8192: "EAccountFlags_LimitedUserForce", + 16384: "EAccountFlags_EmailValidated", + 32768: "EAccountFlags_MarketingTreatment", + 65536: "EAccountFlags_OGGInviteOptOut", + 131072: "EAccountFlags_ForcePasswordChange", + 262144: "EAccountFlags_ForceEmailVerification", + 524288: "EAccountFlags_LogonExtraSecurity", + 1048576: "EAccountFlags_LogonExtraSecurityDisabled", + 2097152: "EAccountFlags_Steam2MigrationComplete", + 4194304: "EAccountFlags_NeedLogs", + 8388608: "EAccountFlags_Lockdown", + 16777216: "EAccountFlags_MasterAppEditor", + 33554432: "EAccountFlags_BannedFromWebAPI", + 67108864: "EAccountFlags_ClansOnlyFromFriends", + 134217728: "EAccountFlags_GlobalModerator", +} + +func (e EAccountFlags) String() string { + if s, ok := EAccountFlags_name[e]; ok { + return s + } + var flags []string + for k, v := range EAccountFlags_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EClanPermission int32 + +const ( + EClanPermission_Nobody EClanPermission = 0 + EClanPermission_Owner EClanPermission = 1 + EClanPermission_Officer EClanPermission = 2 + EClanPermission_OwnerAndOfficer EClanPermission = 3 + EClanPermission_Member EClanPermission = 4 + EClanPermission_Moderator EClanPermission = 8 + EClanPermission_OwnerOfficerModerator EClanPermission = EClanPermission_Owner | EClanPermission_Officer | EClanPermission_Moderator + EClanPermission_AllMembers EClanPermission = EClanPermission_Owner | EClanPermission_Officer | EClanPermission_Moderator | EClanPermission_Member + EClanPermission_OGGGameOwner EClanPermission = 16 + EClanPermission_NonMember EClanPermission = 128 + EClanPermission_MemberAllowed EClanPermission = EClanPermission_NonMember | EClanPermission_Member + EClanPermission_ModeratorAllowed EClanPermission = EClanPermission_NonMember | EClanPermission_Member | EClanPermission_Moderator + EClanPermission_OfficerAllowed EClanPermission = EClanPermission_NonMember | EClanPermission_Member | EClanPermission_Moderator | EClanPermission_Officer + EClanPermission_OwnerAllowed EClanPermission = EClanPermission_NonMember | EClanPermission_Member | EClanPermission_Moderator | EClanPermission_Officer | EClanPermission_Owner + EClanPermission_Anybody EClanPermission = EClanPermission_NonMember | EClanPermission_Member | EClanPermission_Moderator | EClanPermission_Officer | EClanPermission_Owner +) + +var EClanPermission_name = map[EClanPermission]string{ + 0: "EClanPermission_Nobody", + 1: "EClanPermission_Owner", + 2: "EClanPermission_Officer", + 3: "EClanPermission_OwnerAndOfficer", + 4: "EClanPermission_Member", + 8: "EClanPermission_Moderator", + 11: "EClanPermission_OwnerOfficerModerator", + 15: "EClanPermission_AllMembers", + 16: "EClanPermission_OGGGameOwner", + 128: "EClanPermission_NonMember", + 132: "EClanPermission_MemberAllowed", + 140: "EClanPermission_ModeratorAllowed", + 142: "EClanPermission_OfficerAllowed", + 143: "EClanPermission_OwnerAllowed", +} + +func (e EClanPermission) String() string { + if s, ok := EClanPermission_name[e]; ok { + return s + } + var flags []string + for k, v := range EClanPermission_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatPermission int32 + +const ( + EChatPermission_Close EChatPermission = 1 + EChatPermission_Invite EChatPermission = 2 + EChatPermission_Talk EChatPermission = 8 + EChatPermission_Kick EChatPermission = 16 + EChatPermission_Mute EChatPermission = 32 + EChatPermission_SetMetadata EChatPermission = 64 + EChatPermission_ChangePermissions EChatPermission = 128 + EChatPermission_Ban EChatPermission = 256 + EChatPermission_ChangeAccess EChatPermission = 512 + EChatPermission_EveryoneNotInClanDefault EChatPermission = EChatPermission_Talk + EChatPermission_EveryoneDefault EChatPermission = EChatPermission_Talk | EChatPermission_Invite + EChatPermission_MemberDefault EChatPermission = EChatPermission_Ban | EChatPermission_Kick | EChatPermission_Talk | EChatPermission_Invite + EChatPermission_OfficerDefault EChatPermission = EChatPermission_Ban | EChatPermission_Kick | EChatPermission_Talk | EChatPermission_Invite + EChatPermission_OwnerDefault EChatPermission = EChatPermission_ChangeAccess | EChatPermission_Ban | EChatPermission_SetMetadata | EChatPermission_Mute | EChatPermission_Kick | EChatPermission_Talk | EChatPermission_Invite | EChatPermission_Close + EChatPermission_Mask EChatPermission = 1019 +) + +var EChatPermission_name = map[EChatPermission]string{ + 1: "EChatPermission_Close", + 2: "EChatPermission_Invite", + 8: "EChatPermission_Talk", + 16: "EChatPermission_Kick", + 32: "EChatPermission_Mute", + 64: "EChatPermission_SetMetadata", + 128: "EChatPermission_ChangePermissions", + 256: "EChatPermission_Ban", + 512: "EChatPermission_ChangeAccess", + 10: "EChatPermission_EveryoneDefault", + 282: "EChatPermission_MemberDefault", + 891: "EChatPermission_OwnerDefault", + 1019: "EChatPermission_Mask", +} + +func (e EChatPermission) String() string { + if s, ok := EChatPermission_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatPermission_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EFriendFlags int32 + +const ( + EFriendFlags_None EFriendFlags = 0 + EFriendFlags_Blocked EFriendFlags = 1 + EFriendFlags_FriendshipRequested EFriendFlags = 2 + EFriendFlags_Immediate EFriendFlags = 4 + EFriendFlags_ClanMember EFriendFlags = 8 + EFriendFlags_OnGameServer EFriendFlags = 16 + EFriendFlags_RequestingFriendship EFriendFlags = 128 + EFriendFlags_RequestingInfo EFriendFlags = 256 + EFriendFlags_Ignored EFriendFlags = 512 + EFriendFlags_IgnoredFriend EFriendFlags = 1024 + EFriendFlags_Suggested EFriendFlags = 2048 + EFriendFlags_FlagAll EFriendFlags = 65535 +) + +var EFriendFlags_name = map[EFriendFlags]string{ + 0: "EFriendFlags_None", + 1: "EFriendFlags_Blocked", + 2: "EFriendFlags_FriendshipRequested", + 4: "EFriendFlags_Immediate", + 8: "EFriendFlags_ClanMember", + 16: "EFriendFlags_OnGameServer", + 128: "EFriendFlags_RequestingFriendship", + 256: "EFriendFlags_RequestingInfo", + 512: "EFriendFlags_Ignored", + 1024: "EFriendFlags_IgnoredFriend", + 2048: "EFriendFlags_Suggested", + 65535: "EFriendFlags_FlagAll", +} + +func (e EFriendFlags) String() string { + if s, ok := EFriendFlags_name[e]; ok { + return s + } + var flags []string + for k, v := range EFriendFlags_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EPersonaStateFlag int32 + +const ( + EPersonaStateFlag_HasRichPresence EPersonaStateFlag = 1 + EPersonaStateFlag_InJoinableGame EPersonaStateFlag = 2 + EPersonaStateFlag_OnlineUsingWeb EPersonaStateFlag = 256 + EPersonaStateFlag_OnlineUsingMobile EPersonaStateFlag = 512 + EPersonaStateFlag_OnlineUsingBigPicture EPersonaStateFlag = 1024 +) + +var EPersonaStateFlag_name = map[EPersonaStateFlag]string{ + 1: "EPersonaStateFlag_HasRichPresence", + 2: "EPersonaStateFlag_InJoinableGame", + 256: "EPersonaStateFlag_OnlineUsingWeb", + 512: "EPersonaStateFlag_OnlineUsingMobile", + 1024: "EPersonaStateFlag_OnlineUsingBigPicture", +} + +func (e EPersonaStateFlag) String() string { + if s, ok := EPersonaStateFlag_name[e]; ok { + return s + } + var flags []string + for k, v := range EPersonaStateFlag_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EClientPersonaStateFlag int32 + +const ( + EClientPersonaStateFlag_Status EClientPersonaStateFlag = 1 + EClientPersonaStateFlag_PlayerName EClientPersonaStateFlag = 2 + EClientPersonaStateFlag_QueryPort EClientPersonaStateFlag = 4 + EClientPersonaStateFlag_SourceID EClientPersonaStateFlag = 8 + EClientPersonaStateFlag_Presence EClientPersonaStateFlag = 16 + EClientPersonaStateFlag_Metadata EClientPersonaStateFlag = 32 + EClientPersonaStateFlag_LastSeen EClientPersonaStateFlag = 64 + EClientPersonaStateFlag_ClanInfo EClientPersonaStateFlag = 128 + EClientPersonaStateFlag_GameExtraInfo EClientPersonaStateFlag = 256 + EClientPersonaStateFlag_GameDataBlob EClientPersonaStateFlag = 512 + EClientPersonaStateFlag_ClanTag EClientPersonaStateFlag = 1024 + EClientPersonaStateFlag_Facebook EClientPersonaStateFlag = 2048 +) + +var EClientPersonaStateFlag_name = map[EClientPersonaStateFlag]string{ + 1: "EClientPersonaStateFlag_Status", + 2: "EClientPersonaStateFlag_PlayerName", + 4: "EClientPersonaStateFlag_QueryPort", + 8: "EClientPersonaStateFlag_SourceID", + 16: "EClientPersonaStateFlag_Presence", + 32: "EClientPersonaStateFlag_Metadata", + 64: "EClientPersonaStateFlag_LastSeen", + 128: "EClientPersonaStateFlag_ClanInfo", + 256: "EClientPersonaStateFlag_GameExtraInfo", + 512: "EClientPersonaStateFlag_GameDataBlob", + 1024: "EClientPersonaStateFlag_ClanTag", + 2048: "EClientPersonaStateFlag_Facebook", +} + +func (e EClientPersonaStateFlag) String() string { + if s, ok := EClientPersonaStateFlag_name[e]; ok { + return s + } + var flags []string + for k, v := range EClientPersonaStateFlag_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EAppUsageEvent int32 + +const ( + EAppUsageEvent_GameLaunch EAppUsageEvent = 1 + EAppUsageEvent_GameLaunchTrial EAppUsageEvent = 2 + EAppUsageEvent_Media EAppUsageEvent = 3 + EAppUsageEvent_PreloadStart EAppUsageEvent = 4 + EAppUsageEvent_PreloadFinish EAppUsageEvent = 5 + EAppUsageEvent_MarketingMessageView EAppUsageEvent = 6 + EAppUsageEvent_InGameAdViewed EAppUsageEvent = 7 + EAppUsageEvent_GameLaunchFreeWeekend EAppUsageEvent = 8 +) + +var EAppUsageEvent_name = map[EAppUsageEvent]string{ + 1: "EAppUsageEvent_GameLaunch", + 2: "EAppUsageEvent_GameLaunchTrial", + 3: "EAppUsageEvent_Media", + 4: "EAppUsageEvent_PreloadStart", + 5: "EAppUsageEvent_PreloadFinish", + 6: "EAppUsageEvent_MarketingMessageView", + 7: "EAppUsageEvent_InGameAdViewed", + 8: "EAppUsageEvent_GameLaunchFreeWeekend", +} + +func (e EAppUsageEvent) String() string { + if s, ok := EAppUsageEvent_name[e]; ok { + return s + } + var flags []string + for k, v := range EAppUsageEvent_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ELicenseFlags int32 + +const ( + ELicenseFlags_None ELicenseFlags = 0 + ELicenseFlags_Renew ELicenseFlags = 0x01 + ELicenseFlags_RenewalFailed ELicenseFlags = 0x02 + ELicenseFlags_Pending ELicenseFlags = 0x04 + ELicenseFlags_Expired ELicenseFlags = 0x08 + ELicenseFlags_CancelledByUser ELicenseFlags = 0x10 + ELicenseFlags_CancelledByAdmin ELicenseFlags = 0x20 + ELicenseFlags_LowViolenceContent ELicenseFlags = 0x40 + ELicenseFlags_ImportedFromSteam2 ELicenseFlags = 0x80 +) + +var ELicenseFlags_name = map[ELicenseFlags]string{ + 0: "ELicenseFlags_None", + 1: "ELicenseFlags_Renew", + 2: "ELicenseFlags_RenewalFailed", + 4: "ELicenseFlags_Pending", + 8: "ELicenseFlags_Expired", + 16: "ELicenseFlags_CancelledByUser", + 32: "ELicenseFlags_CancelledByAdmin", + 64: "ELicenseFlags_LowViolenceContent", + 128: "ELicenseFlags_ImportedFromSteam2", +} + +func (e ELicenseFlags) String() string { + if s, ok := ELicenseFlags_name[e]; ok { + return s + } + var flags []string + for k, v := range ELicenseFlags_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ELicenseType int32 + +const ( + ELicenseType_NoLicense ELicenseType = 0 + ELicenseType_SinglePurchase ELicenseType = 1 + ELicenseType_SinglePurchaseLimitedUse ELicenseType = 2 + ELicenseType_RecurringCharge ELicenseType = 3 + ELicenseType_RecurringChargeLimitedUse ELicenseType = 4 + ELicenseType_RecurringChargeLimitedUseWithOverages ELicenseType = 5 + ELicenseType_RecurringOption ELicenseType = 6 +) + +var ELicenseType_name = map[ELicenseType]string{ + 0: "ELicenseType_NoLicense", + 1: "ELicenseType_SinglePurchase", + 2: "ELicenseType_SinglePurchaseLimitedUse", + 3: "ELicenseType_RecurringCharge", + 4: "ELicenseType_RecurringChargeLimitedUse", + 5: "ELicenseType_RecurringChargeLimitedUseWithOverages", + 6: "ELicenseType_RecurringOption", +} + +func (e ELicenseType) String() string { + if s, ok := ELicenseType_name[e]; ok { + return s + } + var flags []string + for k, v := range ELicenseType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EPaymentMethod int32 + +const ( + EPaymentMethod_None EPaymentMethod = 0 + EPaymentMethod_ActivationCode EPaymentMethod = 1 + EPaymentMethod_CreditCard EPaymentMethod = 2 + EPaymentMethod_Giropay EPaymentMethod = 3 + EPaymentMethod_PayPal EPaymentMethod = 4 + EPaymentMethod_Ideal EPaymentMethod = 5 + EPaymentMethod_PaySafeCard EPaymentMethod = 6 + EPaymentMethod_Sofort EPaymentMethod = 7 + EPaymentMethod_GuestPass EPaymentMethod = 8 + EPaymentMethod_WebMoney EPaymentMethod = 9 + EPaymentMethod_MoneyBookers EPaymentMethod = 10 + EPaymentMethod_AliPay EPaymentMethod = 11 + EPaymentMethod_Yandex EPaymentMethod = 12 + EPaymentMethod_Kiosk EPaymentMethod = 13 + EPaymentMethod_Qiwi EPaymentMethod = 14 + EPaymentMethod_GameStop EPaymentMethod = 15 + EPaymentMethod_HardwarePromo EPaymentMethod = 16 + EPaymentMethod_MoPay EPaymentMethod = 17 + EPaymentMethod_BoletoBancario EPaymentMethod = 18 + EPaymentMethod_BoaCompraGold EPaymentMethod = 19 + EPaymentMethod_BancoDoBrasilOnline EPaymentMethod = 20 + EPaymentMethod_ItauOnline EPaymentMethod = 21 + EPaymentMethod_BradescoOnline EPaymentMethod = 22 + EPaymentMethod_Pagseguro EPaymentMethod = 23 + EPaymentMethod_VisaBrazil EPaymentMethod = 24 + EPaymentMethod_AmexBrazil EPaymentMethod = 25 + EPaymentMethod_Aura EPaymentMethod = 26 + EPaymentMethod_Hipercard EPaymentMethod = 27 + EPaymentMethod_MastercardBrazil EPaymentMethod = 28 + EPaymentMethod_DinersCardBrazil EPaymentMethod = 29 + EPaymentMethod_AuthorizedDevice EPaymentMethod = 30 + EPaymentMethod_MOLPoints EPaymentMethod = 31 + EPaymentMethod_ClickAndBuy EPaymentMethod = 32 + EPaymentMethod_Beeline EPaymentMethod = 33 + EPaymentMethod_Konbini EPaymentMethod = 34 + EPaymentMethod_EClubPoints EPaymentMethod = 35 + EPaymentMethod_CreditCardJapan EPaymentMethod = 36 + EPaymentMethod_BankTransferJapan EPaymentMethod = 37 + EPaymentMethod_PayEasyJapan EPaymentMethod = 38 + EPaymentMethod_Zong EPaymentMethod = 39 + EPaymentMethod_CultureVoucher EPaymentMethod = 40 + EPaymentMethod_BookVoucher EPaymentMethod = 41 + EPaymentMethod_HappymoneyVoucher EPaymentMethod = 42 + EPaymentMethod_ConvenientStoreVoucher EPaymentMethod = 43 + EPaymentMethod_GameVoucher EPaymentMethod = 44 + EPaymentMethod_Multibanco EPaymentMethod = 45 + EPaymentMethod_Payshop EPaymentMethod = 46 + EPaymentMethod_Maestro EPaymentMethod = 47 + EPaymentMethod_OXXO EPaymentMethod = 48 + EPaymentMethod_ToditoCash EPaymentMethod = 49 + EPaymentMethod_Carnet EPaymentMethod = 50 + EPaymentMethod_SPEI EPaymentMethod = 51 + EPaymentMethod_ThreePay EPaymentMethod = 52 + EPaymentMethod_IsBank EPaymentMethod = 53 + EPaymentMethod_Garanti EPaymentMethod = 54 + EPaymentMethod_Akbank EPaymentMethod = 55 + EPaymentMethod_YapiKredi EPaymentMethod = 56 + EPaymentMethod_Halkbank EPaymentMethod = 57 + EPaymentMethod_BankAsya EPaymentMethod = 58 + EPaymentMethod_Finansbank EPaymentMethod = 59 + EPaymentMethod_DenizBank EPaymentMethod = 60 + EPaymentMethod_PTT EPaymentMethod = 61 + EPaymentMethod_CashU EPaymentMethod = 62 + EPaymentMethod_OneCard EPaymentMethod = 63 + EPaymentMethod_AutoGrant EPaymentMethod = 64 + EPaymentMethod_WebMoneyJapan EPaymentMethod = 65 + EPaymentMethod_Smart2PayTest EPaymentMethod = 66 + EPaymentMethod_Wallet EPaymentMethod = 128 + EPaymentMethod_Valve EPaymentMethod = 129 + EPaymentMethod_SteamPressMaster EPaymentMethod = 130 + EPaymentMethod_StorePromotion EPaymentMethod = 131 + EPaymentMethod_OEMTicket EPaymentMethod = 256 + EPaymentMethod_Split EPaymentMethod = 512 + EPaymentMethod_Complimentary EPaymentMethod = 1024 +) + +var EPaymentMethod_name = map[EPaymentMethod]string{ + 0: "EPaymentMethod_None", + 1: "EPaymentMethod_ActivationCode", + 2: "EPaymentMethod_CreditCard", + 3: "EPaymentMethod_Giropay", + 4: "EPaymentMethod_PayPal", + 5: "EPaymentMethod_Ideal", + 6: "EPaymentMethod_PaySafeCard", + 7: "EPaymentMethod_Sofort", + 8: "EPaymentMethod_GuestPass", + 9: "EPaymentMethod_WebMoney", + 10: "EPaymentMethod_MoneyBookers", + 11: "EPaymentMethod_AliPay", + 12: "EPaymentMethod_Yandex", + 13: "EPaymentMethod_Kiosk", + 14: "EPaymentMethod_Qiwi", + 15: "EPaymentMethod_GameStop", + 16: "EPaymentMethod_HardwarePromo", + 17: "EPaymentMethod_MoPay", + 18: "EPaymentMethod_BoletoBancario", + 19: "EPaymentMethod_BoaCompraGold", + 20: "EPaymentMethod_BancoDoBrasilOnline", + 21: "EPaymentMethod_ItauOnline", + 22: "EPaymentMethod_BradescoOnline", + 23: "EPaymentMethod_Pagseguro", + 24: "EPaymentMethod_VisaBrazil", + 25: "EPaymentMethod_AmexBrazil", + 26: "EPaymentMethod_Aura", + 27: "EPaymentMethod_Hipercard", + 28: "EPaymentMethod_MastercardBrazil", + 29: "EPaymentMethod_DinersCardBrazil", + 30: "EPaymentMethod_AuthorizedDevice", + 31: "EPaymentMethod_MOLPoints", + 32: "EPaymentMethod_ClickAndBuy", + 33: "EPaymentMethod_Beeline", + 34: "EPaymentMethod_Konbini", + 35: "EPaymentMethod_EClubPoints", + 36: "EPaymentMethod_CreditCardJapan", + 37: "EPaymentMethod_BankTransferJapan", + 38: "EPaymentMethod_PayEasyJapan", + 39: "EPaymentMethod_Zong", + 40: "EPaymentMethod_CultureVoucher", + 41: "EPaymentMethod_BookVoucher", + 42: "EPaymentMethod_HappymoneyVoucher", + 43: "EPaymentMethod_ConvenientStoreVoucher", + 44: "EPaymentMethod_GameVoucher", + 45: "EPaymentMethod_Multibanco", + 46: "EPaymentMethod_Payshop", + 47: "EPaymentMethod_Maestro", + 48: "EPaymentMethod_OXXO", + 49: "EPaymentMethod_ToditoCash", + 50: "EPaymentMethod_Carnet", + 51: "EPaymentMethod_SPEI", + 52: "EPaymentMethod_ThreePay", + 53: "EPaymentMethod_IsBank", + 54: "EPaymentMethod_Garanti", + 55: "EPaymentMethod_Akbank", + 56: "EPaymentMethod_YapiKredi", + 57: "EPaymentMethod_Halkbank", + 58: "EPaymentMethod_BankAsya", + 59: "EPaymentMethod_Finansbank", + 60: "EPaymentMethod_DenizBank", + 61: "EPaymentMethod_PTT", + 62: "EPaymentMethod_CashU", + 63: "EPaymentMethod_OneCard", + 64: "EPaymentMethod_AutoGrant", + 65: "EPaymentMethod_WebMoneyJapan", + 66: "EPaymentMethod_Smart2PayTest", + 128: "EPaymentMethod_Wallet", + 129: "EPaymentMethod_Valve", + 130: "EPaymentMethod_SteamPressMaster", + 131: "EPaymentMethod_StorePromotion", + 256: "EPaymentMethod_OEMTicket", + 512: "EPaymentMethod_Split", + 1024: "EPaymentMethod_Complimentary", +} + +func (e EPaymentMethod) String() string { + if s, ok := EPaymentMethod_name[e]; ok { + return s + } + var flags []string + for k, v := range EPaymentMethod_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EIntroducerRouting int32 + +const ( + EIntroducerRouting_FileShare EIntroducerRouting = 0 // Deprecated + EIntroducerRouting_P2PVoiceChat EIntroducerRouting = 1 + EIntroducerRouting_P2PNetworking EIntroducerRouting = 2 +) + +var EIntroducerRouting_name = map[EIntroducerRouting]string{ + 0: "EIntroducerRouting_FileShare", + 1: "EIntroducerRouting_P2PVoiceChat", + 2: "EIntroducerRouting_P2PNetworking", +} + +func (e EIntroducerRouting) String() string { + if s, ok := EIntroducerRouting_name[e]; ok { + return s + } + var flags []string + for k, v := range EIntroducerRouting_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EServerFlags int32 + +const ( + EServerFlags_None EServerFlags = 0 + EServerFlags_Active EServerFlags = 1 + EServerFlags_Secure EServerFlags = 2 + EServerFlags_Dedicated EServerFlags = 4 + EServerFlags_Linux EServerFlags = 8 + EServerFlags_Passworded EServerFlags = 16 + EServerFlags_Private EServerFlags = 32 +) + +var EServerFlags_name = map[EServerFlags]string{ + 0: "EServerFlags_None", + 1: "EServerFlags_Active", + 2: "EServerFlags_Secure", + 4: "EServerFlags_Dedicated", + 8: "EServerFlags_Linux", + 16: "EServerFlags_Passworded", + 32: "EServerFlags_Private", +} + +func (e EServerFlags) String() string { + if s, ok := EServerFlags_name[e]; ok { + return s + } + var flags []string + for k, v := range EServerFlags_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EDenyReason int32 + +const ( + EDenyReason_InvalidVersion EDenyReason = 1 + EDenyReason_Generic EDenyReason = 2 + EDenyReason_NotLoggedOn EDenyReason = 3 + EDenyReason_NoLicense EDenyReason = 4 + EDenyReason_Cheater EDenyReason = 5 + EDenyReason_LoggedInElseWhere EDenyReason = 6 + EDenyReason_UnknownText EDenyReason = 7 + EDenyReason_IncompatibleAnticheat EDenyReason = 8 + EDenyReason_MemoryCorruption EDenyReason = 9 + EDenyReason_IncompatibleSoftware EDenyReason = 10 + EDenyReason_SteamConnectionLost EDenyReason = 11 + EDenyReason_SteamConnectionError EDenyReason = 12 + EDenyReason_SteamResponseTimedOut EDenyReason = 13 + EDenyReason_SteamValidationStalled EDenyReason = 14 + EDenyReason_SteamOwnerLeftGuestUser EDenyReason = 15 +) + +var EDenyReason_name = map[EDenyReason]string{ + 1: "EDenyReason_InvalidVersion", + 2: "EDenyReason_Generic", + 3: "EDenyReason_NotLoggedOn", + 4: "EDenyReason_NoLicense", + 5: "EDenyReason_Cheater", + 6: "EDenyReason_LoggedInElseWhere", + 7: "EDenyReason_UnknownText", + 8: "EDenyReason_IncompatibleAnticheat", + 9: "EDenyReason_MemoryCorruption", + 10: "EDenyReason_IncompatibleSoftware", + 11: "EDenyReason_SteamConnectionLost", + 12: "EDenyReason_SteamConnectionError", + 13: "EDenyReason_SteamResponseTimedOut", + 14: "EDenyReason_SteamValidationStalled", + 15: "EDenyReason_SteamOwnerLeftGuestUser", +} + +func (e EDenyReason) String() string { + if s, ok := EDenyReason_name[e]; ok { + return s + } + var flags []string + for k, v := range EDenyReason_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EClanRank int32 + +const ( + EClanRank_None EClanRank = 0 + EClanRank_Owner EClanRank = 1 + EClanRank_Officer EClanRank = 2 + EClanRank_Member EClanRank = 3 + EClanRank_Moderator EClanRank = 4 +) + +var EClanRank_name = map[EClanRank]string{ + 0: "EClanRank_None", + 1: "EClanRank_Owner", + 2: "EClanRank_Officer", + 3: "EClanRank_Member", + 4: "EClanRank_Moderator", +} + +func (e EClanRank) String() string { + if s, ok := EClanRank_name[e]; ok { + return s + } + var flags []string + for k, v := range EClanRank_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EClanRelationship int32 + +const ( + EClanRelationship_None EClanRelationship = 0 + EClanRelationship_Blocked EClanRelationship = 1 + EClanRelationship_Invited EClanRelationship = 2 + EClanRelationship_Member EClanRelationship = 3 + EClanRelationship_Kicked EClanRelationship = 4 + EClanRelationship_KickAcknowledged EClanRelationship = 5 +) + +var EClanRelationship_name = map[EClanRelationship]string{ + 0: "EClanRelationship_None", + 1: "EClanRelationship_Blocked", + 2: "EClanRelationship_Invited", + 3: "EClanRelationship_Member", + 4: "EClanRelationship_Kicked", + 5: "EClanRelationship_KickAcknowledged", +} + +func (e EClanRelationship) String() string { + if s, ok := EClanRelationship_name[e]; ok { + return s + } + var flags []string + for k, v := range EClanRelationship_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EAuthSessionResponse int32 + +const ( + EAuthSessionResponse_OK EAuthSessionResponse = 0 + EAuthSessionResponse_UserNotConnectedToSteam EAuthSessionResponse = 1 + EAuthSessionResponse_NoLicenseOrExpired EAuthSessionResponse = 2 + EAuthSessionResponse_VACBanned EAuthSessionResponse = 3 + EAuthSessionResponse_LoggedInElseWhere EAuthSessionResponse = 4 + EAuthSessionResponse_VACCheckTimedOut EAuthSessionResponse = 5 + EAuthSessionResponse_AuthTicketCanceled EAuthSessionResponse = 6 + EAuthSessionResponse_AuthTicketInvalidAlreadyUsed EAuthSessionResponse = 7 + EAuthSessionResponse_AuthTicketInvalid EAuthSessionResponse = 8 + EAuthSessionResponse_PublisherIssuedBan EAuthSessionResponse = 9 +) + +var EAuthSessionResponse_name = map[EAuthSessionResponse]string{ + 0: "EAuthSessionResponse_OK", + 1: "EAuthSessionResponse_UserNotConnectedToSteam", + 2: "EAuthSessionResponse_NoLicenseOrExpired", + 3: "EAuthSessionResponse_VACBanned", + 4: "EAuthSessionResponse_LoggedInElseWhere", + 5: "EAuthSessionResponse_VACCheckTimedOut", + 6: "EAuthSessionResponse_AuthTicketCanceled", + 7: "EAuthSessionResponse_AuthTicketInvalidAlreadyUsed", + 8: "EAuthSessionResponse_AuthTicketInvalid", + 9: "EAuthSessionResponse_PublisherIssuedBan", +} + +func (e EAuthSessionResponse) String() string { + if s, ok := EAuthSessionResponse_name[e]; ok { + return s + } + var flags []string + for k, v := range EAuthSessionResponse_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatRoomEnterResponse int32 + +const ( + EChatRoomEnterResponse_Success EChatRoomEnterResponse = 1 + EChatRoomEnterResponse_DoesntExist EChatRoomEnterResponse = 2 + EChatRoomEnterResponse_NotAllowed EChatRoomEnterResponse = 3 + EChatRoomEnterResponse_Full EChatRoomEnterResponse = 4 + EChatRoomEnterResponse_Error EChatRoomEnterResponse = 5 + EChatRoomEnterResponse_Banned EChatRoomEnterResponse = 6 + EChatRoomEnterResponse_Limited EChatRoomEnterResponse = 7 + EChatRoomEnterResponse_ClanDisabled EChatRoomEnterResponse = 8 + EChatRoomEnterResponse_CommunityBan EChatRoomEnterResponse = 9 + EChatRoomEnterResponse_MemberBlockedYou EChatRoomEnterResponse = 10 + EChatRoomEnterResponse_YouBlockedMember EChatRoomEnterResponse = 11 + EChatRoomEnterResponse_NoRankingDataLobby EChatRoomEnterResponse = 12 // Deprecated + EChatRoomEnterResponse_NoRankingDataUser EChatRoomEnterResponse = 13 // Deprecated + EChatRoomEnterResponse_RankOutOfRange EChatRoomEnterResponse = 14 // Deprecated +) + +var EChatRoomEnterResponse_name = map[EChatRoomEnterResponse]string{ + 1: "EChatRoomEnterResponse_Success", + 2: "EChatRoomEnterResponse_DoesntExist", + 3: "EChatRoomEnterResponse_NotAllowed", + 4: "EChatRoomEnterResponse_Full", + 5: "EChatRoomEnterResponse_Error", + 6: "EChatRoomEnterResponse_Banned", + 7: "EChatRoomEnterResponse_Limited", + 8: "EChatRoomEnterResponse_ClanDisabled", + 9: "EChatRoomEnterResponse_CommunityBan", + 10: "EChatRoomEnterResponse_MemberBlockedYou", + 11: "EChatRoomEnterResponse_YouBlockedMember", + 12: "EChatRoomEnterResponse_NoRankingDataLobby", + 13: "EChatRoomEnterResponse_NoRankingDataUser", + 14: "EChatRoomEnterResponse_RankOutOfRange", +} + +func (e EChatRoomEnterResponse) String() string { + if s, ok := EChatRoomEnterResponse_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatRoomEnterResponse_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatRoomType int32 + +const ( + EChatRoomType_Friend EChatRoomType = 1 + EChatRoomType_MUC EChatRoomType = 2 + EChatRoomType_Lobby EChatRoomType = 3 +) + +var EChatRoomType_name = map[EChatRoomType]string{ + 1: "EChatRoomType_Friend", + 2: "EChatRoomType_MUC", + 3: "EChatRoomType_Lobby", +} + +func (e EChatRoomType) String() string { + if s, ok := EChatRoomType_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatRoomType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatInfoType int32 + +const ( + EChatInfoType_StateChange EChatInfoType = 1 + EChatInfoType_InfoUpdate EChatInfoType = 2 + EChatInfoType_MemberLimitChange EChatInfoType = 3 +) + +var EChatInfoType_name = map[EChatInfoType]string{ + 1: "EChatInfoType_StateChange", + 2: "EChatInfoType_InfoUpdate", + 3: "EChatInfoType_MemberLimitChange", +} + +func (e EChatInfoType) String() string { + if s, ok := EChatInfoType_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatInfoType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatAction int32 + +const ( + EChatAction_InviteChat EChatAction = 1 + EChatAction_Kick EChatAction = 2 + EChatAction_Ban EChatAction = 3 + EChatAction_UnBan EChatAction = 4 + EChatAction_StartVoiceSpeak EChatAction = 5 + EChatAction_EndVoiceSpeak EChatAction = 6 + EChatAction_LockChat EChatAction = 7 + EChatAction_UnlockChat EChatAction = 8 + EChatAction_CloseChat EChatAction = 9 + EChatAction_SetJoinable EChatAction = 10 + EChatAction_SetUnjoinable EChatAction = 11 + EChatAction_SetOwner EChatAction = 12 + EChatAction_SetInvisibleToFriends EChatAction = 13 + EChatAction_SetVisibleToFriends EChatAction = 14 + EChatAction_SetModerated EChatAction = 15 + EChatAction_SetUnmoderated EChatAction = 16 +) + +var EChatAction_name = map[EChatAction]string{ + 1: "EChatAction_InviteChat", + 2: "EChatAction_Kick", + 3: "EChatAction_Ban", + 4: "EChatAction_UnBan", + 5: "EChatAction_StartVoiceSpeak", + 6: "EChatAction_EndVoiceSpeak", + 7: "EChatAction_LockChat", + 8: "EChatAction_UnlockChat", + 9: "EChatAction_CloseChat", + 10: "EChatAction_SetJoinable", + 11: "EChatAction_SetUnjoinable", + 12: "EChatAction_SetOwner", + 13: "EChatAction_SetInvisibleToFriends", + 14: "EChatAction_SetVisibleToFriends", + 15: "EChatAction_SetModerated", + 16: "EChatAction_SetUnmoderated", +} + +func (e EChatAction) String() string { + if s, ok := EChatAction_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatAction_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatActionResult int32 + +const ( + EChatActionResult_Success EChatActionResult = 1 + EChatActionResult_Error EChatActionResult = 2 + EChatActionResult_NotPermitted EChatActionResult = 3 + EChatActionResult_NotAllowedOnClanMember EChatActionResult = 4 + EChatActionResult_NotAllowedOnBannedUser EChatActionResult = 5 + EChatActionResult_NotAllowedOnChatOwner EChatActionResult = 6 + EChatActionResult_NotAllowedOnSelf EChatActionResult = 7 + EChatActionResult_ChatDoesntExist EChatActionResult = 8 + EChatActionResult_ChatFull EChatActionResult = 9 + EChatActionResult_VoiceSlotsFull EChatActionResult = 10 +) + +var EChatActionResult_name = map[EChatActionResult]string{ + 1: "EChatActionResult_Success", + 2: "EChatActionResult_Error", + 3: "EChatActionResult_NotPermitted", + 4: "EChatActionResult_NotAllowedOnClanMember", + 5: "EChatActionResult_NotAllowedOnBannedUser", + 6: "EChatActionResult_NotAllowedOnChatOwner", + 7: "EChatActionResult_NotAllowedOnSelf", + 8: "EChatActionResult_ChatDoesntExist", + 9: "EChatActionResult_ChatFull", + 10: "EChatActionResult_VoiceSlotsFull", +} + +func (e EChatActionResult) String() string { + if s, ok := EChatActionResult_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatActionResult_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EAppInfoSection int32 + +const ( + EAppInfoSection_Unknown EAppInfoSection = 0 + EAppInfoSection_All EAppInfoSection = 1 + EAppInfoSection_First EAppInfoSection = 2 + EAppInfoSection_Common EAppInfoSection = 2 + EAppInfoSection_Extended EAppInfoSection = 3 + EAppInfoSection_Config EAppInfoSection = 4 + EAppInfoSection_Stats EAppInfoSection = 5 + EAppInfoSection_Install EAppInfoSection = 6 + EAppInfoSection_Depots EAppInfoSection = 7 + EAppInfoSection_VAC EAppInfoSection = 8 + EAppInfoSection_DRM EAppInfoSection = 9 + EAppInfoSection_UFS EAppInfoSection = 10 + EAppInfoSection_OGG EAppInfoSection = 11 + EAppInfoSection_Items EAppInfoSection = 12 // Deprecated + EAppInfoSection_ItemsUNUSED EAppInfoSection = 12 // Deprecated + EAppInfoSection_Policies EAppInfoSection = 13 + EAppInfoSection_SysReqs EAppInfoSection = 14 + EAppInfoSection_Community EAppInfoSection = 15 + EAppInfoSection_Store EAppInfoSection = 16 + EAppInfoSection_Max EAppInfoSection = 17 +) + +var EAppInfoSection_name = map[EAppInfoSection]string{ + 0: "EAppInfoSection_Unknown", + 1: "EAppInfoSection_All", + 2: "EAppInfoSection_First", + 3: "EAppInfoSection_Extended", + 4: "EAppInfoSection_Config", + 5: "EAppInfoSection_Stats", + 6: "EAppInfoSection_Install", + 7: "EAppInfoSection_Depots", + 8: "EAppInfoSection_VAC", + 9: "EAppInfoSection_DRM", + 10: "EAppInfoSection_UFS", + 11: "EAppInfoSection_OGG", + 12: "EAppInfoSection_Items", + 13: "EAppInfoSection_Policies", + 14: "EAppInfoSection_SysReqs", + 15: "EAppInfoSection_Community", + 16: "EAppInfoSection_Store", + 17: "EAppInfoSection_Max", +} + +func (e EAppInfoSection) String() string { + if s, ok := EAppInfoSection_name[e]; ok { + return s + } + var flags []string + for k, v := range EAppInfoSection_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EContentDownloadSourceType int32 + +const ( + EContentDownloadSourceType_Invalid EContentDownloadSourceType = 0 + EContentDownloadSourceType_CS EContentDownloadSourceType = 1 + EContentDownloadSourceType_CDN EContentDownloadSourceType = 2 + EContentDownloadSourceType_LCS EContentDownloadSourceType = 3 + EContentDownloadSourceType_ProxyCache EContentDownloadSourceType = 4 + EContentDownloadSourceType_Max EContentDownloadSourceType = 5 +) + +var EContentDownloadSourceType_name = map[EContentDownloadSourceType]string{ + 0: "EContentDownloadSourceType_Invalid", + 1: "EContentDownloadSourceType_CS", + 2: "EContentDownloadSourceType_CDN", + 3: "EContentDownloadSourceType_LCS", + 4: "EContentDownloadSourceType_ProxyCache", + 5: "EContentDownloadSourceType_Max", +} + +func (e EContentDownloadSourceType) String() string { + if s, ok := EContentDownloadSourceType_name[e]; ok { + return s + } + var flags []string + for k, v := range EContentDownloadSourceType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EPlatformType int32 + +const ( + EPlatformType_Unknown EPlatformType = 0 + EPlatformType_Win32 EPlatformType = 1 + EPlatformType_Win64 EPlatformType = 2 + EPlatformType_Linux EPlatformType = 3 + EPlatformType_OSX EPlatformType = 4 + EPlatformType_PS3 EPlatformType = 5 + EPlatformType_Max EPlatformType = 6 +) + +var EPlatformType_name = map[EPlatformType]string{ + 0: "EPlatformType_Unknown", + 1: "EPlatformType_Win32", + 2: "EPlatformType_Win64", + 3: "EPlatformType_Linux", + 4: "EPlatformType_OSX", + 5: "EPlatformType_PS3", + 6: "EPlatformType_Max", +} + +func (e EPlatformType) String() string { + if s, ok := EPlatformType_name[e]; ok { + return s + } + var flags []string + for k, v := range EPlatformType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EOSType int32 + +const ( + EOSType_Unknown EOSType = -1 + EOSType_UMQ EOSType = -400 + EOSType_PS3 EOSType = -300 + EOSType_MacOSUnknown EOSType = -102 + EOSType_MacOS104 EOSType = -101 + EOSType_MacOS105 EOSType = -100 + EOSType_MacOS1058 EOSType = -99 + EOSType_MacOS106 EOSType = -95 + EOSType_MacOS1063 EOSType = -94 + EOSType_MacOS1064_slgu EOSType = -93 + EOSType_MacOS1067 EOSType = -92 + EOSType_MacOS107 EOSType = -90 + EOSType_MacOS108 EOSType = -89 + EOSType_MacOS109 EOSType = -88 + EOSType_MacOS1010 EOSType = -87 + EOSType_LinuxUnknown EOSType = -203 + EOSType_Linux22 EOSType = -202 + EOSType_Linux24 EOSType = -201 + EOSType_Linux26 EOSType = -200 + EOSType_Linux32 EOSType = -199 + EOSType_Linux35 EOSType = -198 + EOSType_Linux36 EOSType = -197 + EOSType_Linux310 EOSType = -196 + EOSType_WinUnknown EOSType = 0 + EOSType_Win311 EOSType = 1 + EOSType_Win95 EOSType = 2 + EOSType_Win98 EOSType = 3 + EOSType_WinME EOSType = 4 + EOSType_WinNT EOSType = 5 + EOSType_Win200 EOSType = 6 + EOSType_WinXP EOSType = 7 + EOSType_Win2003 EOSType = 8 + EOSType_WinVista EOSType = 9 + EOSType_Win7 EOSType = 10 + EOSType_Windows7 EOSType = 10 // Deprecated: renamed to Win7 + EOSType_Win2008 EOSType = 11 + EOSType_Win2012 EOSType = 12 + EOSType_Win8 EOSType = 13 + EOSType_Windows8 EOSType = 13 // Deprecated: renamed to Win8 + EOSType_Win81 EOSType = 14 + EOSType_Windows81 EOSType = 14 // Deprecated: renamed to Win81 + EOSType_Win2012R2 EOSType = 15 + EOSType_Win10 EOSType = 16 + EOSType_WinMAX EOSType = 15 + EOSType_Max EOSType = 26 +) + +var EOSType_name = map[EOSType]string{ + -1: "EOSType_Unknown", + -400: "EOSType_UMQ", + -300: "EOSType_PS3", + -102: "EOSType_MacOSUnknown", + -101: "EOSType_MacOS104", + -100: "EOSType_MacOS105", + -99: "EOSType_MacOS1058", + -95: "EOSType_MacOS106", + -94: "EOSType_MacOS1063", + -93: "EOSType_MacOS1064_slgu", + -92: "EOSType_MacOS1067", + -90: "EOSType_MacOS107", + -89: "EOSType_MacOS108", + -88: "EOSType_MacOS109", + -87: "EOSType_MacOS1010", + -203: "EOSType_LinuxUnknown", + -202: "EOSType_Linux22", + -201: "EOSType_Linux24", + -200: "EOSType_Linux26", + -199: "EOSType_Linux32", + -198: "EOSType_Linux35", + -197: "EOSType_Linux36", + -196: "EOSType_Linux310", + 0: "EOSType_WinUnknown", + 1: "EOSType_Win311", + 2: "EOSType_Win95", + 3: "EOSType_Win98", + 4: "EOSType_WinME", + 5: "EOSType_WinNT", + 6: "EOSType_Win200", + 7: "EOSType_WinXP", + 8: "EOSType_Win2003", + 9: "EOSType_WinVista", + 10: "EOSType_Win7", + 11: "EOSType_Win2008", + 12: "EOSType_Win2012", + 13: "EOSType_Win8", + 14: "EOSType_Win81", + 15: "EOSType_Win2012R2", + 16: "EOSType_Win10", + 26: "EOSType_Max", +} + +func (e EOSType) String() string { + if s, ok := EOSType_name[e]; ok { + return s + } + var flags []string + for k, v := range EOSType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EServerType int32 + +const ( + EServerType_Invalid EServerType = -1 + EServerType_First EServerType = 0 + EServerType_Shell EServerType = 0 + EServerType_GM EServerType = 1 + EServerType_BUM EServerType = 2 + EServerType_AM EServerType = 3 + EServerType_BS EServerType = 4 + EServerType_VS EServerType = 5 + EServerType_ATS EServerType = 6 + EServerType_CM EServerType = 7 + EServerType_FBS EServerType = 8 + EServerType_FG EServerType = 9 // Deprecated: renamed to BoxMonitor + EServerType_BoxMonitor EServerType = 9 + EServerType_SS EServerType = 10 + EServerType_DRMS EServerType = 11 + EServerType_HubOBSOLETE EServerType = 12 // Deprecated + EServerType_Console EServerType = 13 + EServerType_ASBOBSOLETE EServerType = 14 // Deprecated + EServerType_PICS EServerType = 14 + EServerType_Client EServerType = 15 + EServerType_BootstrapOBSOLETE EServerType = 16 // Deprecated + EServerType_DP EServerType = 17 + EServerType_WG EServerType = 18 + EServerType_SM EServerType = 19 + EServerType_UFS EServerType = 21 + EServerType_Util EServerType = 23 + EServerType_DSS EServerType = 24 // Deprecated: renamed to Community + EServerType_Community EServerType = 24 + EServerType_P2PRelayOBSOLETE EServerType = 25 // Deprecated + EServerType_AppInformation EServerType = 26 + EServerType_Spare EServerType = 27 + EServerType_FTS EServerType = 28 + EServerType_EPM EServerType = 29 + EServerType_PS EServerType = 30 + EServerType_IS EServerType = 31 + EServerType_CCS EServerType = 32 + EServerType_DFS EServerType = 33 + EServerType_LBS EServerType = 34 + EServerType_MDS EServerType = 35 + EServerType_CS EServerType = 36 + EServerType_GC EServerType = 37 + EServerType_NS EServerType = 38 + EServerType_OGS EServerType = 39 + EServerType_WebAPI EServerType = 40 + EServerType_UDS EServerType = 41 + EServerType_MMS EServerType = 42 + EServerType_GMS EServerType = 43 + EServerType_KGS EServerType = 44 + EServerType_UCM EServerType = 45 + EServerType_RM EServerType = 46 + EServerType_FS EServerType = 47 + EServerType_Econ EServerType = 48 + EServerType_Backpack EServerType = 49 + EServerType_UGS EServerType = 50 + EServerType_Store EServerType = 51 + EServerType_MoneyStats EServerType = 52 + EServerType_CRE EServerType = 53 + EServerType_UMQ EServerType = 54 + EServerType_Workshop EServerType = 55 + EServerType_BRP EServerType = 56 + EServerType_GCH EServerType = 57 + EServerType_MPAS EServerType = 58 + EServerType_Trade EServerType = 59 + EServerType_Secrets EServerType = 60 + EServerType_Logsink EServerType = 61 + EServerType_Market EServerType = 62 + EServerType_Quest EServerType = 63 + EServerType_WDS EServerType = 64 + EServerType_ACS EServerType = 65 + EServerType_PNP EServerType = 66 + EServerType_Max EServerType = 67 +) + +var EServerType_name = map[EServerType]string{ + -1: "EServerType_Invalid", + 0: "EServerType_First", + 1: "EServerType_GM", + 2: "EServerType_BUM", + 3: "EServerType_AM", + 4: "EServerType_BS", + 5: "EServerType_VS", + 6: "EServerType_ATS", + 7: "EServerType_CM", + 8: "EServerType_FBS", + 9: "EServerType_FG", + 10: "EServerType_SS", + 11: "EServerType_DRMS", + 12: "EServerType_HubOBSOLETE", + 13: "EServerType_Console", + 14: "EServerType_ASBOBSOLETE", + 15: "EServerType_Client", + 16: "EServerType_BootstrapOBSOLETE", + 17: "EServerType_DP", + 18: "EServerType_WG", + 19: "EServerType_SM", + 21: "EServerType_UFS", + 23: "EServerType_Util", + 24: "EServerType_DSS", + 25: "EServerType_P2PRelayOBSOLETE", + 26: "EServerType_AppInformation", + 27: "EServerType_Spare", + 28: "EServerType_FTS", + 29: "EServerType_EPM", + 30: "EServerType_PS", + 31: "EServerType_IS", + 32: "EServerType_CCS", + 33: "EServerType_DFS", + 34: "EServerType_LBS", + 35: "EServerType_MDS", + 36: "EServerType_CS", + 37: "EServerType_GC", + 38: "EServerType_NS", + 39: "EServerType_OGS", + 40: "EServerType_WebAPI", + 41: "EServerType_UDS", + 42: "EServerType_MMS", + 43: "EServerType_GMS", + 44: "EServerType_KGS", + 45: "EServerType_UCM", + 46: "EServerType_RM", + 47: "EServerType_FS", + 48: "EServerType_Econ", + 49: "EServerType_Backpack", + 50: "EServerType_UGS", + 51: "EServerType_Store", + 52: "EServerType_MoneyStats", + 53: "EServerType_CRE", + 54: "EServerType_UMQ", + 55: "EServerType_Workshop", + 56: "EServerType_BRP", + 57: "EServerType_GCH", + 58: "EServerType_MPAS", + 59: "EServerType_Trade", + 60: "EServerType_Secrets", + 61: "EServerType_Logsink", + 62: "EServerType_Market", + 63: "EServerType_Quest", + 64: "EServerType_WDS", + 65: "EServerType_ACS", + 66: "EServerType_PNP", + 67: "EServerType_Max", +} + +func (e EServerType) String() string { + if s, ok := EServerType_name[e]; ok { + return s + } + var flags []string + for k, v := range EServerType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EBillingType int32 + +const ( + EBillingType_NoCost EBillingType = 0 + EBillingType_BillOnceOnly EBillingType = 1 + EBillingType_BillMonthly EBillingType = 2 + EBillingType_ProofOfPrepurchaseOnly EBillingType = 3 + EBillingType_GuestPass EBillingType = 4 + EBillingType_HardwarePromo EBillingType = 5 + EBillingType_Gift EBillingType = 6 + EBillingType_AutoGrant EBillingType = 7 + EBillingType_OEMTicket EBillingType = 8 + EBillingType_RecurringOption EBillingType = 9 + EBillingType_NumBillingTypes EBillingType = 10 +) + +var EBillingType_name = map[EBillingType]string{ + 0: "EBillingType_NoCost", + 1: "EBillingType_BillOnceOnly", + 2: "EBillingType_BillMonthly", + 3: "EBillingType_ProofOfPrepurchaseOnly", + 4: "EBillingType_GuestPass", + 5: "EBillingType_HardwarePromo", + 6: "EBillingType_Gift", + 7: "EBillingType_AutoGrant", + 8: "EBillingType_OEMTicket", + 9: "EBillingType_RecurringOption", + 10: "EBillingType_NumBillingTypes", +} + +func (e EBillingType) String() string { + if s, ok := EBillingType_name[e]; ok { + return s + } + var flags []string + for k, v := range EBillingType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EActivationCodeClass uint32 + +const ( + EActivationCodeClass_WonCDKey EActivationCodeClass = 0 + EActivationCodeClass_ValveCDKey EActivationCodeClass = 1 + EActivationCodeClass_Doom3CDKey EActivationCodeClass = 2 + EActivationCodeClass_DBLookup EActivationCodeClass = 3 + EActivationCodeClass_Steam2010Key EActivationCodeClass = 4 + EActivationCodeClass_Max EActivationCodeClass = 5 + EActivationCodeClass_Test EActivationCodeClass = 2147483647 + EActivationCodeClass_Invalid EActivationCodeClass = 4294967295 +) + +var EActivationCodeClass_name = map[EActivationCodeClass]string{ + 0: "EActivationCodeClass_WonCDKey", + 1: "EActivationCodeClass_ValveCDKey", + 2: "EActivationCodeClass_Doom3CDKey", + 3: "EActivationCodeClass_DBLookup", + 4: "EActivationCodeClass_Steam2010Key", + 5: "EActivationCodeClass_Max", + 2147483647: "EActivationCodeClass_Test", + 4294967295: "EActivationCodeClass_Invalid", +} + +func (e EActivationCodeClass) String() string { + if s, ok := EActivationCodeClass_name[e]; ok { + return s + } + var flags []string + for k, v := range EActivationCodeClass_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatMemberStateChange int32 + +const ( + EChatMemberStateChange_Entered EChatMemberStateChange = 0x01 + EChatMemberStateChange_Left EChatMemberStateChange = 0x02 + EChatMemberStateChange_Disconnected EChatMemberStateChange = 0x04 + EChatMemberStateChange_Kicked EChatMemberStateChange = 0x08 + EChatMemberStateChange_Banned EChatMemberStateChange = 0x10 + EChatMemberStateChange_VoiceSpeaking EChatMemberStateChange = 0x1000 + EChatMemberStateChange_VoiceDoneSpeaking EChatMemberStateChange = 0x2000 +) + +var EChatMemberStateChange_name = map[EChatMemberStateChange]string{ + 1: "EChatMemberStateChange_Entered", + 2: "EChatMemberStateChange_Left", + 4: "EChatMemberStateChange_Disconnected", + 8: "EChatMemberStateChange_Kicked", + 16: "EChatMemberStateChange_Banned", + 4096: "EChatMemberStateChange_VoiceSpeaking", + 8192: "EChatMemberStateChange_VoiceDoneSpeaking", +} + +func (e EChatMemberStateChange) String() string { + if s, ok := EChatMemberStateChange_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatMemberStateChange_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ERegionCode uint8 + +const ( + ERegionCode_USEast ERegionCode = 0x00 + ERegionCode_USWest ERegionCode = 0x01 + ERegionCode_SouthAmerica ERegionCode = 0x02 + ERegionCode_Europe ERegionCode = 0x03 + ERegionCode_Asia ERegionCode = 0x04 + ERegionCode_Australia ERegionCode = 0x05 + ERegionCode_MiddleEast ERegionCode = 0x06 + ERegionCode_Africa ERegionCode = 0x07 + ERegionCode_World ERegionCode = 0xFF +) + +var ERegionCode_name = map[ERegionCode]string{ + 0: "ERegionCode_USEast", + 1: "ERegionCode_USWest", + 2: "ERegionCode_SouthAmerica", + 3: "ERegionCode_Europe", + 4: "ERegionCode_Asia", + 5: "ERegionCode_Australia", + 6: "ERegionCode_MiddleEast", + 7: "ERegionCode_Africa", + 255: "ERegionCode_World", +} + +func (e ERegionCode) String() string { + if s, ok := ERegionCode_name[e]; ok { + return s + } + var flags []string + for k, v := range ERegionCode_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ECurrencyCode int32 + +const ( + ECurrencyCode_Invalid ECurrencyCode = 0 + ECurrencyCode_USD ECurrencyCode = 1 + ECurrencyCode_GBP ECurrencyCode = 2 + ECurrencyCode_EUR ECurrencyCode = 3 + ECurrencyCode_CHF ECurrencyCode = 4 + ECurrencyCode_RUB ECurrencyCode = 5 + ECurrencyCode_PLN ECurrencyCode = 6 + ECurrencyCode_BRL ECurrencyCode = 7 + ECurrencyCode_JPY ECurrencyCode = 8 + ECurrencyCode_NOK ECurrencyCode = 9 + ECurrencyCode_IDR ECurrencyCode = 10 + ECurrencyCode_MYR ECurrencyCode = 11 + ECurrencyCode_PHP ECurrencyCode = 12 + ECurrencyCode_SGD ECurrencyCode = 13 + ECurrencyCode_THB ECurrencyCode = 14 + ECurrencyCode_VND ECurrencyCode = 15 + ECurrencyCode_KRW ECurrencyCode = 16 + ECurrencyCode_TRY ECurrencyCode = 17 + ECurrencyCode_UAH ECurrencyCode = 18 + ECurrencyCode_MXN ECurrencyCode = 19 + ECurrencyCode_CAD ECurrencyCode = 20 + ECurrencyCode_AUD ECurrencyCode = 21 + ECurrencyCode_NZD ECurrencyCode = 22 + ECurrencyCode_CNY ECurrencyCode = 23 + ECurrencyCode_INR ECurrencyCode = 24 + ECurrencyCode_CLP ECurrencyCode = 25 + ECurrencyCode_PEN ECurrencyCode = 26 + ECurrencyCode_COP ECurrencyCode = 27 + ECurrencyCode_ZAR ECurrencyCode = 28 + ECurrencyCode_HKD ECurrencyCode = 29 + ECurrencyCode_TWD ECurrencyCode = 30 + ECurrencyCode_SAR ECurrencyCode = 31 + ECurrencyCode_AED ECurrencyCode = 32 + ECurrencyCode_Max ECurrencyCode = 33 +) + +var ECurrencyCode_name = map[ECurrencyCode]string{ + 0: "ECurrencyCode_Invalid", + 1: "ECurrencyCode_USD", + 2: "ECurrencyCode_GBP", + 3: "ECurrencyCode_EUR", + 4: "ECurrencyCode_CHF", + 5: "ECurrencyCode_RUB", + 6: "ECurrencyCode_PLN", + 7: "ECurrencyCode_BRL", + 8: "ECurrencyCode_JPY", + 9: "ECurrencyCode_NOK", + 10: "ECurrencyCode_IDR", + 11: "ECurrencyCode_MYR", + 12: "ECurrencyCode_PHP", + 13: "ECurrencyCode_SGD", + 14: "ECurrencyCode_THB", + 15: "ECurrencyCode_VND", + 16: "ECurrencyCode_KRW", + 17: "ECurrencyCode_TRY", + 18: "ECurrencyCode_UAH", + 19: "ECurrencyCode_MXN", + 20: "ECurrencyCode_CAD", + 21: "ECurrencyCode_AUD", + 22: "ECurrencyCode_NZD", + 23: "ECurrencyCode_CNY", + 24: "ECurrencyCode_INR", + 25: "ECurrencyCode_CLP", + 26: "ECurrencyCode_PEN", + 27: "ECurrencyCode_COP", + 28: "ECurrencyCode_ZAR", + 29: "ECurrencyCode_HKD", + 30: "ECurrencyCode_TWD", + 31: "ECurrencyCode_SAR", + 32: "ECurrencyCode_AED", + 33: "ECurrencyCode_Max", +} + +func (e ECurrencyCode) String() string { + if s, ok := ECurrencyCode_name[e]; ok { + return s + } + var flags []string + for k, v := range ECurrencyCode_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EDepotFileFlag int32 + +const ( + EDepotFileFlag_UserConfig EDepotFileFlag = 1 + EDepotFileFlag_VersionedUserConfig EDepotFileFlag = 2 + EDepotFileFlag_Encrypted EDepotFileFlag = 4 + EDepotFileFlag_ReadOnly EDepotFileFlag = 8 + EDepotFileFlag_Hidden EDepotFileFlag = 16 + EDepotFileFlag_Executable EDepotFileFlag = 32 + EDepotFileFlag_Directory EDepotFileFlag = 64 + EDepotFileFlag_CustomExecutable EDepotFileFlag = 128 + EDepotFileFlag_InstallScript EDepotFileFlag = 256 +) + +var EDepotFileFlag_name = map[EDepotFileFlag]string{ + 1: "EDepotFileFlag_UserConfig", + 2: "EDepotFileFlag_VersionedUserConfig", + 4: "EDepotFileFlag_Encrypted", + 8: "EDepotFileFlag_ReadOnly", + 16: "EDepotFileFlag_Hidden", + 32: "EDepotFileFlag_Executable", + 64: "EDepotFileFlag_Directory", + 128: "EDepotFileFlag_CustomExecutable", + 256: "EDepotFileFlag_InstallScript", +} + +func (e EDepotFileFlag) String() string { + if s, ok := EDepotFileFlag_name[e]; ok { + return s + } + var flags []string + for k, v := range EDepotFileFlag_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EWorkshopEnumerationType int32 + +const ( + EWorkshopEnumerationType_RankedByVote EWorkshopEnumerationType = 0 + EWorkshopEnumerationType_Recent EWorkshopEnumerationType = 1 + EWorkshopEnumerationType_Trending EWorkshopEnumerationType = 2 + EWorkshopEnumerationType_FavoriteOfFriends EWorkshopEnumerationType = 3 + EWorkshopEnumerationType_VotedByFriends EWorkshopEnumerationType = 4 + EWorkshopEnumerationType_ContentByFriends EWorkshopEnumerationType = 5 + EWorkshopEnumerationType_RecentFromFollowedUsers EWorkshopEnumerationType = 6 +) + +var EWorkshopEnumerationType_name = map[EWorkshopEnumerationType]string{ + 0: "EWorkshopEnumerationType_RankedByVote", + 1: "EWorkshopEnumerationType_Recent", + 2: "EWorkshopEnumerationType_Trending", + 3: "EWorkshopEnumerationType_FavoriteOfFriends", + 4: "EWorkshopEnumerationType_VotedByFriends", + 5: "EWorkshopEnumerationType_ContentByFriends", + 6: "EWorkshopEnumerationType_RecentFromFollowedUsers", +} + +func (e EWorkshopEnumerationType) String() string { + if s, ok := EWorkshopEnumerationType_name[e]; ok { + return s + } + var flags []string + for k, v := range EWorkshopEnumerationType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EPublishedFileVisibility int32 + +const ( + EPublishedFileVisibility_Public EPublishedFileVisibility = 0 + EPublishedFileVisibility_FriendsOnly EPublishedFileVisibility = 1 + EPublishedFileVisibility_Private EPublishedFileVisibility = 2 +) + +var EPublishedFileVisibility_name = map[EPublishedFileVisibility]string{ + 0: "EPublishedFileVisibility_Public", + 1: "EPublishedFileVisibility_FriendsOnly", + 2: "EPublishedFileVisibility_Private", +} + +func (e EPublishedFileVisibility) String() string { + if s, ok := EPublishedFileVisibility_name[e]; ok { + return s + } + var flags []string + for k, v := range EPublishedFileVisibility_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EWorkshopFileType int32 + +const ( + EWorkshopFileType_First EWorkshopFileType = 0 + EWorkshopFileType_Community EWorkshopFileType = 0 + EWorkshopFileType_Microtransaction EWorkshopFileType = 1 + EWorkshopFileType_Collection EWorkshopFileType = 2 + EWorkshopFileType_Art EWorkshopFileType = 3 + EWorkshopFileType_Video EWorkshopFileType = 4 + EWorkshopFileType_Screenshot EWorkshopFileType = 5 + EWorkshopFileType_Game EWorkshopFileType = 6 + EWorkshopFileType_Software EWorkshopFileType = 7 + EWorkshopFileType_Concept EWorkshopFileType = 8 + EWorkshopFileType_WebGuide EWorkshopFileType = 9 + EWorkshopFileType_IntegratedGuide EWorkshopFileType = 10 + EWorkshopFileType_Merch EWorkshopFileType = 11 + EWorkshopFileType_ControllerBinding EWorkshopFileType = 12 + EWorkshopFileType_SteamworksAccessInvite EWorkshopFileType = 13 + EWorkshopFileType_SteamVideo EWorkshopFileType = 14 + EWorkshopFileType_GameManagedItem EWorkshopFileType = 15 + EWorkshopFileType_Max EWorkshopFileType = 16 +) + +var EWorkshopFileType_name = map[EWorkshopFileType]string{ + 0: "EWorkshopFileType_First", + 1: "EWorkshopFileType_Microtransaction", + 2: "EWorkshopFileType_Collection", + 3: "EWorkshopFileType_Art", + 4: "EWorkshopFileType_Video", + 5: "EWorkshopFileType_Screenshot", + 6: "EWorkshopFileType_Game", + 7: "EWorkshopFileType_Software", + 8: "EWorkshopFileType_Concept", + 9: "EWorkshopFileType_WebGuide", + 10: "EWorkshopFileType_IntegratedGuide", + 11: "EWorkshopFileType_Merch", + 12: "EWorkshopFileType_ControllerBinding", + 13: "EWorkshopFileType_SteamworksAccessInvite", + 14: "EWorkshopFileType_SteamVideo", + 15: "EWorkshopFileType_GameManagedItem", + 16: "EWorkshopFileType_Max", +} + +func (e EWorkshopFileType) String() string { + if s, ok := EWorkshopFileType_name[e]; ok { + return s + } + var flags []string + for k, v := range EWorkshopFileType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EWorkshopFileAction int32 + +const ( + EWorkshopFileAction_Played EWorkshopFileAction = 0 + EWorkshopFileAction_Completed EWorkshopFileAction = 1 +) + +var EWorkshopFileAction_name = map[EWorkshopFileAction]string{ + 0: "EWorkshopFileAction_Played", + 1: "EWorkshopFileAction_Completed", +} + +func (e EWorkshopFileAction) String() string { + if s, ok := EWorkshopFileAction_name[e]; ok { + return s + } + var flags []string + for k, v := range EWorkshopFileAction_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EEconTradeResponse int32 + +const ( + EEconTradeResponse_Accepted EEconTradeResponse = 0 + EEconTradeResponse_Declined EEconTradeResponse = 1 + EEconTradeResponse_TradeBannedInitiator EEconTradeResponse = 2 + EEconTradeResponse_TradeBannedTarget EEconTradeResponse = 3 + EEconTradeResponse_TargetAlreadyTrading EEconTradeResponse = 4 + EEconTradeResponse_Disabled EEconTradeResponse = 5 + EEconTradeResponse_NotLoggedIn EEconTradeResponse = 6 + EEconTradeResponse_Cancel EEconTradeResponse = 7 + EEconTradeResponse_TooSoon EEconTradeResponse = 8 + EEconTradeResponse_TooSoonPenalty EEconTradeResponse = 9 + EEconTradeResponse_ConnectionFailed EEconTradeResponse = 10 + EEconTradeResponse_AlreadyTrading EEconTradeResponse = 11 + EEconTradeResponse_AlreadyHasTradeRequest EEconTradeResponse = 12 + EEconTradeResponse_NoResponse EEconTradeResponse = 13 + EEconTradeResponse_CyberCafeInitiator EEconTradeResponse = 14 + EEconTradeResponse_CyberCafeTarget EEconTradeResponse = 15 + EEconTradeResponse_SchoolLabInitiator EEconTradeResponse = 16 + EEconTradeResponse_SchoolLabTarget EEconTradeResponse = 16 + EEconTradeResponse_InitiatorBlockedTarget EEconTradeResponse = 18 + EEconTradeResponse_InitiatorNeedsVerifiedEmail EEconTradeResponse = 20 + EEconTradeResponse_InitiatorNeedsSteamGuard EEconTradeResponse = 21 + EEconTradeResponse_TargetAccountCannotTrade EEconTradeResponse = 22 + EEconTradeResponse_InitiatorSteamGuardDuration EEconTradeResponse = 23 + EEconTradeResponse_InitiatorPasswordResetProbation EEconTradeResponse = 24 + EEconTradeResponse_InitiatorNewDeviceCooldown EEconTradeResponse = 25 + EEconTradeResponse_OKToDeliver EEconTradeResponse = 50 +) + +var EEconTradeResponse_name = map[EEconTradeResponse]string{ + 0: "EEconTradeResponse_Accepted", + 1: "EEconTradeResponse_Declined", + 2: "EEconTradeResponse_TradeBannedInitiator", + 3: "EEconTradeResponse_TradeBannedTarget", + 4: "EEconTradeResponse_TargetAlreadyTrading", + 5: "EEconTradeResponse_Disabled", + 6: "EEconTradeResponse_NotLoggedIn", + 7: "EEconTradeResponse_Cancel", + 8: "EEconTradeResponse_TooSoon", + 9: "EEconTradeResponse_TooSoonPenalty", + 10: "EEconTradeResponse_ConnectionFailed", + 11: "EEconTradeResponse_AlreadyTrading", + 12: "EEconTradeResponse_AlreadyHasTradeRequest", + 13: "EEconTradeResponse_NoResponse", + 14: "EEconTradeResponse_CyberCafeInitiator", + 15: "EEconTradeResponse_CyberCafeTarget", + 16: "EEconTradeResponse_SchoolLabInitiator", + 18: "EEconTradeResponse_InitiatorBlockedTarget", + 20: "EEconTradeResponse_InitiatorNeedsVerifiedEmail", + 21: "EEconTradeResponse_InitiatorNeedsSteamGuard", + 22: "EEconTradeResponse_TargetAccountCannotTrade", + 23: "EEconTradeResponse_InitiatorSteamGuardDuration", + 24: "EEconTradeResponse_InitiatorPasswordResetProbation", + 25: "EEconTradeResponse_InitiatorNewDeviceCooldown", + 50: "EEconTradeResponse_OKToDeliver", +} + +func (e EEconTradeResponse) String() string { + if s, ok := EEconTradeResponse_name[e]; ok { + return s + } + var flags []string + for k, v := range EEconTradeResponse_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EMarketingMessageFlags int32 + +const ( + EMarketingMessageFlags_None EMarketingMessageFlags = 0 + EMarketingMessageFlags_HighPriority EMarketingMessageFlags = 1 + EMarketingMessageFlags_PlatformWindows EMarketingMessageFlags = 2 + EMarketingMessageFlags_PlatformMac EMarketingMessageFlags = 4 + EMarketingMessageFlags_PlatformLinux EMarketingMessageFlags = 8 + EMarketingMessageFlags_PlatformRestrictions EMarketingMessageFlags = EMarketingMessageFlags_PlatformWindows | EMarketingMessageFlags_PlatformMac | EMarketingMessageFlags_PlatformLinux +) + +var EMarketingMessageFlags_name = map[EMarketingMessageFlags]string{ + 0: "EMarketingMessageFlags_None", + 1: "EMarketingMessageFlags_HighPriority", + 2: "EMarketingMessageFlags_PlatformWindows", + 4: "EMarketingMessageFlags_PlatformMac", + 8: "EMarketingMessageFlags_PlatformLinux", + 14: "EMarketingMessageFlags_PlatformRestrictions", +} + +func (e EMarketingMessageFlags) String() string { + if s, ok := EMarketingMessageFlags_name[e]; ok { + return s + } + var flags []string + for k, v := range EMarketingMessageFlags_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ENewsUpdateType int32 + +const ( + ENewsUpdateType_AppNews ENewsUpdateType = 0 + ENewsUpdateType_SteamAds ENewsUpdateType = 1 + ENewsUpdateType_SteamNews ENewsUpdateType = 2 + ENewsUpdateType_CDDBUpdate ENewsUpdateType = 3 + ENewsUpdateType_ClientUpdate ENewsUpdateType = 4 +) + +var ENewsUpdateType_name = map[ENewsUpdateType]string{ + 0: "ENewsUpdateType_AppNews", + 1: "ENewsUpdateType_SteamAds", + 2: "ENewsUpdateType_SteamNews", + 3: "ENewsUpdateType_CDDBUpdate", + 4: "ENewsUpdateType_ClientUpdate", +} + +func (e ENewsUpdateType) String() string { + if s, ok := ENewsUpdateType_name[e]; ok { + return s + } + var flags []string + for k, v := range ENewsUpdateType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ESystemIMType int32 + +const ( + ESystemIMType_RawText ESystemIMType = 0 + ESystemIMType_InvalidCard ESystemIMType = 1 + ESystemIMType_RecurringPurchaseFailed ESystemIMType = 2 + ESystemIMType_CardWillExpire ESystemIMType = 3 + ESystemIMType_SubscriptionExpired ESystemIMType = 4 + ESystemIMType_GuestPassReceived ESystemIMType = 5 + ESystemIMType_GuestPassGranted ESystemIMType = 6 + ESystemIMType_GiftRevoked ESystemIMType = 7 + ESystemIMType_SupportMessage ESystemIMType = 8 + ESystemIMType_SupportMessageClearAlert ESystemIMType = 9 + ESystemIMType_Max ESystemIMType = 10 +) + +var ESystemIMType_name = map[ESystemIMType]string{ + 0: "ESystemIMType_RawText", + 1: "ESystemIMType_InvalidCard", + 2: "ESystemIMType_RecurringPurchaseFailed", + 3: "ESystemIMType_CardWillExpire", + 4: "ESystemIMType_SubscriptionExpired", + 5: "ESystemIMType_GuestPassReceived", + 6: "ESystemIMType_GuestPassGranted", + 7: "ESystemIMType_GiftRevoked", + 8: "ESystemIMType_SupportMessage", + 9: "ESystemIMType_SupportMessageClearAlert", + 10: "ESystemIMType_Max", +} + +func (e ESystemIMType) String() string { + if s, ok := ESystemIMType_name[e]; ok { + return s + } + var flags []string + for k, v := range ESystemIMType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EChatFlags int32 + +const ( + EChatFlags_Locked EChatFlags = 1 + EChatFlags_InvisibleToFriends EChatFlags = 2 + EChatFlags_Moderated EChatFlags = 4 + EChatFlags_Unjoinable EChatFlags = 8 +) + +var EChatFlags_name = map[EChatFlags]string{ + 1: "EChatFlags_Locked", + 2: "EChatFlags_InvisibleToFriends", + 4: "EChatFlags_Moderated", + 8: "EChatFlags_Unjoinable", +} + +func (e EChatFlags) String() string { + if s, ok := EChatFlags_name[e]; ok { + return s + } + var flags []string + for k, v := range EChatFlags_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ERemoteStoragePlatform int32 + +const ( + ERemoteStoragePlatform_None ERemoteStoragePlatform = 0 + ERemoteStoragePlatform_Windows ERemoteStoragePlatform = 1 + ERemoteStoragePlatform_OSX ERemoteStoragePlatform = 2 + ERemoteStoragePlatform_PS3 ERemoteStoragePlatform = 4 + ERemoteStoragePlatform_Linux ERemoteStoragePlatform = 8 + ERemoteStoragePlatform_Reserved1 ERemoteStoragePlatform = 8 // Deprecated + ERemoteStoragePlatform_Reserved2 ERemoteStoragePlatform = 16 + ERemoteStoragePlatform_All ERemoteStoragePlatform = -1 +) + +var ERemoteStoragePlatform_name = map[ERemoteStoragePlatform]string{ + 0: "ERemoteStoragePlatform_None", + 1: "ERemoteStoragePlatform_Windows", + 2: "ERemoteStoragePlatform_OSX", + 4: "ERemoteStoragePlatform_PS3", + 8: "ERemoteStoragePlatform_Linux", + 16: "ERemoteStoragePlatform_Reserved2", + -1: "ERemoteStoragePlatform_All", +} + +func (e ERemoteStoragePlatform) String() string { + if s, ok := ERemoteStoragePlatform_name[e]; ok { + return s + } + var flags []string + for k, v := range ERemoteStoragePlatform_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EDRMBlobDownloadType int32 + +const ( + EDRMBlobDownloadType_Error EDRMBlobDownloadType = 0 + EDRMBlobDownloadType_File EDRMBlobDownloadType = 1 + EDRMBlobDownloadType_Parts EDRMBlobDownloadType = 2 + EDRMBlobDownloadType_Compressed EDRMBlobDownloadType = 4 + EDRMBlobDownloadType_AllMask EDRMBlobDownloadType = 7 + EDRMBlobDownloadType_IsJob EDRMBlobDownloadType = 8 + EDRMBlobDownloadType_HighPriority EDRMBlobDownloadType = 16 + EDRMBlobDownloadType_AddTimestamp EDRMBlobDownloadType = 32 + EDRMBlobDownloadType_LowPriority EDRMBlobDownloadType = 64 +) + +var EDRMBlobDownloadType_name = map[EDRMBlobDownloadType]string{ + 0: "EDRMBlobDownloadType_Error", + 1: "EDRMBlobDownloadType_File", + 2: "EDRMBlobDownloadType_Parts", + 4: "EDRMBlobDownloadType_Compressed", + 7: "EDRMBlobDownloadType_AllMask", + 8: "EDRMBlobDownloadType_IsJob", + 16: "EDRMBlobDownloadType_HighPriority", + 32: "EDRMBlobDownloadType_AddTimestamp", + 64: "EDRMBlobDownloadType_LowPriority", +} + +func (e EDRMBlobDownloadType) String() string { + if s, ok := EDRMBlobDownloadType_name[e]; ok { + return s + } + var flags []string + for k, v := range EDRMBlobDownloadType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EDRMBlobDownloadErrorDetail int32 + +const ( + EDRMBlobDownloadErrorDetail_None EDRMBlobDownloadErrorDetail = 0 + EDRMBlobDownloadErrorDetail_DownloadFailed EDRMBlobDownloadErrorDetail = 1 + EDRMBlobDownloadErrorDetail_TargetLocked EDRMBlobDownloadErrorDetail = 2 + EDRMBlobDownloadErrorDetail_OpenZip EDRMBlobDownloadErrorDetail = 3 + EDRMBlobDownloadErrorDetail_ReadZipDirectory EDRMBlobDownloadErrorDetail = 4 + EDRMBlobDownloadErrorDetail_UnexpectedZipEntry EDRMBlobDownloadErrorDetail = 5 + EDRMBlobDownloadErrorDetail_UnzipFullFile EDRMBlobDownloadErrorDetail = 6 + EDRMBlobDownloadErrorDetail_UnknownBlobType EDRMBlobDownloadErrorDetail = 7 + EDRMBlobDownloadErrorDetail_UnzipStrips EDRMBlobDownloadErrorDetail = 8 + EDRMBlobDownloadErrorDetail_UnzipMergeGuid EDRMBlobDownloadErrorDetail = 9 + EDRMBlobDownloadErrorDetail_UnzipSignature EDRMBlobDownloadErrorDetail = 10 + EDRMBlobDownloadErrorDetail_ApplyStrips EDRMBlobDownloadErrorDetail = 11 + EDRMBlobDownloadErrorDetail_ApplyMergeGuid EDRMBlobDownloadErrorDetail = 12 + EDRMBlobDownloadErrorDetail_ApplySignature EDRMBlobDownloadErrorDetail = 13 + EDRMBlobDownloadErrorDetail_AppIdMismatch EDRMBlobDownloadErrorDetail = 14 + EDRMBlobDownloadErrorDetail_AppIdUnexpected EDRMBlobDownloadErrorDetail = 15 + EDRMBlobDownloadErrorDetail_AppliedSignatureCorrupt EDRMBlobDownloadErrorDetail = 16 + EDRMBlobDownloadErrorDetail_ApplyValveSignatureHeader EDRMBlobDownloadErrorDetail = 17 + EDRMBlobDownloadErrorDetail_UnzipValveSignatureHeader EDRMBlobDownloadErrorDetail = 18 + EDRMBlobDownloadErrorDetail_PathManipulationError EDRMBlobDownloadErrorDetail = 19 + EDRMBlobDownloadErrorDetail_TargetLocked_Base EDRMBlobDownloadErrorDetail = 65536 + EDRMBlobDownloadErrorDetail_TargetLocked_Max EDRMBlobDownloadErrorDetail = 131071 + EDRMBlobDownloadErrorDetail_NextBase EDRMBlobDownloadErrorDetail = 131072 +) + +var EDRMBlobDownloadErrorDetail_name = map[EDRMBlobDownloadErrorDetail]string{ + 0: "EDRMBlobDownloadErrorDetail_None", + 1: "EDRMBlobDownloadErrorDetail_DownloadFailed", + 2: "EDRMBlobDownloadErrorDetail_TargetLocked", + 3: "EDRMBlobDownloadErrorDetail_OpenZip", + 4: "EDRMBlobDownloadErrorDetail_ReadZipDirectory", + 5: "EDRMBlobDownloadErrorDetail_UnexpectedZipEntry", + 6: "EDRMBlobDownloadErrorDetail_UnzipFullFile", + 7: "EDRMBlobDownloadErrorDetail_UnknownBlobType", + 8: "EDRMBlobDownloadErrorDetail_UnzipStrips", + 9: "EDRMBlobDownloadErrorDetail_UnzipMergeGuid", + 10: "EDRMBlobDownloadErrorDetail_UnzipSignature", + 11: "EDRMBlobDownloadErrorDetail_ApplyStrips", + 12: "EDRMBlobDownloadErrorDetail_ApplyMergeGuid", + 13: "EDRMBlobDownloadErrorDetail_ApplySignature", + 14: "EDRMBlobDownloadErrorDetail_AppIdMismatch", + 15: "EDRMBlobDownloadErrorDetail_AppIdUnexpected", + 16: "EDRMBlobDownloadErrorDetail_AppliedSignatureCorrupt", + 17: "EDRMBlobDownloadErrorDetail_ApplyValveSignatureHeader", + 18: "EDRMBlobDownloadErrorDetail_UnzipValveSignatureHeader", + 19: "EDRMBlobDownloadErrorDetail_PathManipulationError", + 65536: "EDRMBlobDownloadErrorDetail_TargetLocked_Base", + 131071: "EDRMBlobDownloadErrorDetail_TargetLocked_Max", + 131072: "EDRMBlobDownloadErrorDetail_NextBase", +} + +func (e EDRMBlobDownloadErrorDetail) String() string { + if s, ok := EDRMBlobDownloadErrorDetail_name[e]; ok { + return s + } + var flags []string + for k, v := range EDRMBlobDownloadErrorDetail_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EClientStat int32 + +const ( + EClientStat_P2PConnectionsUDP EClientStat = 0 + EClientStat_P2PConnectionsRelay EClientStat = 1 + EClientStat_P2PGameConnections EClientStat = 2 + EClientStat_P2PVoiceConnections EClientStat = 3 + EClientStat_BytesDownloaded EClientStat = 4 + EClientStat_Max EClientStat = 5 +) + +var EClientStat_name = map[EClientStat]string{ + 0: "EClientStat_P2PConnectionsUDP", + 1: "EClientStat_P2PConnectionsRelay", + 2: "EClientStat_P2PGameConnections", + 3: "EClientStat_P2PVoiceConnections", + 4: "EClientStat_BytesDownloaded", + 5: "EClientStat_Max", +} + +func (e EClientStat) String() string { + if s, ok := EClientStat_name[e]; ok { + return s + } + var flags []string + for k, v := range EClientStat_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EClientStatAggregateMethod int32 + +const ( + EClientStatAggregateMethod_LatestOnly EClientStatAggregateMethod = 0 + EClientStatAggregateMethod_Sum EClientStatAggregateMethod = 1 + EClientStatAggregateMethod_Event EClientStatAggregateMethod = 2 + EClientStatAggregateMethod_Scalar EClientStatAggregateMethod = 3 +) + +var EClientStatAggregateMethod_name = map[EClientStatAggregateMethod]string{ + 0: "EClientStatAggregateMethod_LatestOnly", + 1: "EClientStatAggregateMethod_Sum", + 2: "EClientStatAggregateMethod_Event", + 3: "EClientStatAggregateMethod_Scalar", +} + +func (e EClientStatAggregateMethod) String() string { + if s, ok := EClientStatAggregateMethod_name[e]; ok { + return s + } + var flags []string + for k, v := range EClientStatAggregateMethod_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ELeaderboardDataRequest int32 + +const ( + ELeaderboardDataRequest_Global ELeaderboardDataRequest = 0 + ELeaderboardDataRequest_GlobalAroundUser ELeaderboardDataRequest = 1 + ELeaderboardDataRequest_Friends ELeaderboardDataRequest = 2 + ELeaderboardDataRequest_Users ELeaderboardDataRequest = 3 +) + +var ELeaderboardDataRequest_name = map[ELeaderboardDataRequest]string{ + 0: "ELeaderboardDataRequest_Global", + 1: "ELeaderboardDataRequest_GlobalAroundUser", + 2: "ELeaderboardDataRequest_Friends", + 3: "ELeaderboardDataRequest_Users", +} + +func (e ELeaderboardDataRequest) String() string { + if s, ok := ELeaderboardDataRequest_name[e]; ok { + return s + } + var flags []string + for k, v := range ELeaderboardDataRequest_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ELeaderboardSortMethod int32 + +const ( + ELeaderboardSortMethod_None ELeaderboardSortMethod = 0 + ELeaderboardSortMethod_Ascending ELeaderboardSortMethod = 1 + ELeaderboardSortMethod_Descending ELeaderboardSortMethod = 2 +) + +var ELeaderboardSortMethod_name = map[ELeaderboardSortMethod]string{ + 0: "ELeaderboardSortMethod_None", + 1: "ELeaderboardSortMethod_Ascending", + 2: "ELeaderboardSortMethod_Descending", +} + +func (e ELeaderboardSortMethod) String() string { + if s, ok := ELeaderboardSortMethod_name[e]; ok { + return s + } + var flags []string + for k, v := range ELeaderboardSortMethod_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ELeaderboardDisplayType int32 + +const ( + ELeaderboardDisplayType_None ELeaderboardDisplayType = 0 + ELeaderboardDisplayType_Numeric ELeaderboardDisplayType = 1 + ELeaderboardDisplayType_TimeSeconds ELeaderboardDisplayType = 2 + ELeaderboardDisplayType_TimeMilliSeconds ELeaderboardDisplayType = 3 +) + +var ELeaderboardDisplayType_name = map[ELeaderboardDisplayType]string{ + 0: "ELeaderboardDisplayType_None", + 1: "ELeaderboardDisplayType_Numeric", + 2: "ELeaderboardDisplayType_TimeSeconds", + 3: "ELeaderboardDisplayType_TimeMilliSeconds", +} + +func (e ELeaderboardDisplayType) String() string { + if s, ok := ELeaderboardDisplayType_name[e]; ok { + return s + } + var flags []string + for k, v := range ELeaderboardDisplayType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type ELeaderboardUploadScoreMethod int32 + +const ( + ELeaderboardUploadScoreMethod_None ELeaderboardUploadScoreMethod = 0 + ELeaderboardUploadScoreMethod_KeepBest ELeaderboardUploadScoreMethod = 1 + ELeaderboardUploadScoreMethod_ForceUpdate ELeaderboardUploadScoreMethod = 2 +) + +var ELeaderboardUploadScoreMethod_name = map[ELeaderboardUploadScoreMethod]string{ + 0: "ELeaderboardUploadScoreMethod_None", + 1: "ELeaderboardUploadScoreMethod_KeepBest", + 2: "ELeaderboardUploadScoreMethod_ForceUpdate", +} + +func (e ELeaderboardUploadScoreMethod) String() string { + if s, ok := ELeaderboardUploadScoreMethod_name[e]; ok { + return s + } + var flags []string + for k, v := range ELeaderboardUploadScoreMethod_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EUCMFilePrivacyState int32 + +const ( + EUCMFilePrivacyState_Invalid EUCMFilePrivacyState = -1 + EUCMFilePrivacyState_Private EUCMFilePrivacyState = 2 + EUCMFilePrivacyState_FriendsOnly EUCMFilePrivacyState = 4 + EUCMFilePrivacyState_Public EUCMFilePrivacyState = 8 + EUCMFilePrivacyState_All EUCMFilePrivacyState = EUCMFilePrivacyState_Public | EUCMFilePrivacyState_FriendsOnly | EUCMFilePrivacyState_Private +) + +var EUCMFilePrivacyState_name = map[EUCMFilePrivacyState]string{ + -1: "EUCMFilePrivacyState_Invalid", + 2: "EUCMFilePrivacyState_Private", + 4: "EUCMFilePrivacyState_FriendsOnly", + 8: "EUCMFilePrivacyState_Public", + 14: "EUCMFilePrivacyState_All", +} + +func (e EUCMFilePrivacyState) String() string { + if s, ok := EUCMFilePrivacyState_name[e]; ok { + return s + } + var flags []string + for k, v := range EUCMFilePrivacyState_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} + +type EUdpPacketType uint8 + +const ( + EUdpPacketType_Invalid EUdpPacketType = 0 + EUdpPacketType_ChallengeReq EUdpPacketType = 1 + EUdpPacketType_Challenge EUdpPacketType = 2 + EUdpPacketType_Connect EUdpPacketType = 3 + EUdpPacketType_Accept EUdpPacketType = 4 + EUdpPacketType_Disconnect EUdpPacketType = 5 + EUdpPacketType_Data EUdpPacketType = 6 + EUdpPacketType_Datagram EUdpPacketType = 7 + EUdpPacketType_Max EUdpPacketType = 8 +) + +var EUdpPacketType_name = map[EUdpPacketType]string{ + 0: "EUdpPacketType_Invalid", + 1: "EUdpPacketType_ChallengeReq", + 2: "EUdpPacketType_Challenge", + 3: "EUdpPacketType_Connect", + 4: "EUdpPacketType_Accept", + 5: "EUdpPacketType_Disconnect", + 6: "EUdpPacketType_Data", + 7: "EUdpPacketType_Datagram", + 8: "EUdpPacketType_Max", +} + +func (e EUdpPacketType) String() string { + if s, ok := EUdpPacketType_name[e]; ok { + return s + } + var flags []string + for k, v := range EUdpPacketType_name { + if e&k != 0 { + flags = append(flags, v) + } + } + if len(flags) == 0 { + return fmt.Sprintf("%d", e) + } + sort.Strings(flags) + return strings.Join(flags, " | ") +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go new file mode 100644 index 00000000..fa5028d8 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/messages.go @@ -0,0 +1,2543 @@ +// Generated code +// DO NOT EDIT + +package steamlang + +import ( + "encoding/binary" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + "github.com/Philipp15b/go-steam/rwu" + "github.com/Philipp15b/go-steam/steamid" + "github.com/golang/protobuf/proto" + "io" +) + +const UdpHeader_MAGIC uint32 = 0x31305356 + +type UdpHeader struct { + Magic uint32 + PayloadSize uint16 + PacketType EUdpPacketType + Flags uint8 + SourceConnID uint32 + DestConnID uint32 + SeqThis uint32 + SeqAck uint32 + PacketsInMsg uint32 + MsgStartSeq uint32 + MsgSize uint32 +} + +func NewUdpHeader() *UdpHeader { + return &UdpHeader{ + Magic: UdpHeader_MAGIC, + PacketType: EUdpPacketType_Invalid, + SourceConnID: 512, + } +} + +func (d *UdpHeader) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Magic) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.PayloadSize) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.PacketType) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Flags) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SourceConnID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.DestConnID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SeqThis) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SeqAck) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.PacketsInMsg) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.MsgStartSeq) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.MsgSize) + return err +} + +func (d *UdpHeader) Deserialize(r io.Reader) error { + var err error + d.Magic, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.PayloadSize, err = rwu.ReadUint16(r) + if err != nil { + return err + } + t0, err := rwu.ReadUint8(r) + if err != nil { + return err + } + d.PacketType = EUdpPacketType(t0) + d.Flags, err = rwu.ReadUint8(r) + if err != nil { + return err + } + d.SourceConnID, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.DestConnID, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.SeqThis, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.SeqAck, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.PacketsInMsg, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.MsgStartSeq, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.MsgSize, err = rwu.ReadUint32(r) + return err +} + +const ChallengeData_CHALLENGE_MASK uint32 = 0xA426DF2B + +type ChallengeData struct { + ChallengeValue uint32 + ServerLoad uint32 +} + +func NewChallengeData() *ChallengeData { + return &ChallengeData{} +} + +func (d *ChallengeData) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.ChallengeValue) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ServerLoad) + return err +} + +func (d *ChallengeData) Deserialize(r io.Reader) error { + var err error + d.ChallengeValue, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.ServerLoad, err = rwu.ReadUint32(r) + return err +} + +const ConnectData_CHALLENGE_MASK uint32 = ChallengeData_CHALLENGE_MASK + +type ConnectData struct { + ChallengeValue uint32 +} + +func NewConnectData() *ConnectData { + return &ConnectData{} +} + +func (d *ConnectData) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.ChallengeValue) + return err +} + +func (d *ConnectData) Deserialize(r io.Reader) error { + var err error + d.ChallengeValue, err = rwu.ReadUint32(r) + return err +} + +type Accept struct { +} + +func NewAccept() *Accept { + return &Accept{} +} + +func (d *Accept) Serialize(w io.Writer) error { + var err error + return err +} + +func (d *Accept) Deserialize(r io.Reader) error { + var err error + return err +} + +type Datagram struct { +} + +func NewDatagram() *Datagram { + return &Datagram{} +} + +func (d *Datagram) Serialize(w io.Writer) error { + var err error + return err +} + +func (d *Datagram) Deserialize(r io.Reader) error { + var err error + return err +} + +type Disconnect struct { +} + +func NewDisconnect() *Disconnect { + return &Disconnect{} +} + +func (d *Disconnect) Serialize(w io.Writer) error { + var err error + return err +} + +func (d *Disconnect) Deserialize(r io.Reader) error { + var err error + return err +} + +type MsgHdr struct { + Msg EMsg + TargetJobID uint64 + SourceJobID uint64 +} + +func NewMsgHdr() *MsgHdr { + return &MsgHdr{ + Msg: EMsg_Invalid, + TargetJobID: ^uint64(0), + SourceJobID: ^uint64(0), + } +} + +func (d *MsgHdr) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Msg) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.TargetJobID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SourceJobID) + return err +} + +func (d *MsgHdr) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Msg = EMsg(t0) + d.TargetJobID, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.SourceJobID, err = rwu.ReadUint64(r) + return err +} + +type ExtendedClientMsgHdr struct { + Msg EMsg + HeaderSize uint8 + HeaderVersion uint16 + TargetJobID uint64 + SourceJobID uint64 + HeaderCanary uint8 + SteamID steamid.SteamId + SessionID int32 +} + +func NewExtendedClientMsgHdr() *ExtendedClientMsgHdr { + return &ExtendedClientMsgHdr{ + Msg: EMsg_Invalid, + HeaderSize: 36, + HeaderVersion: 2, + TargetJobID: ^uint64(0), + SourceJobID: ^uint64(0), + HeaderCanary: 239, + } +} + +func (d *ExtendedClientMsgHdr) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Msg) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.HeaderSize) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.HeaderVersion) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.TargetJobID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SourceJobID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.HeaderCanary) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SessionID) + return err +} + +func (d *ExtendedClientMsgHdr) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Msg = EMsg(t0) + d.HeaderSize, err = rwu.ReadUint8(r) + if err != nil { + return err + } + d.HeaderVersion, err = rwu.ReadUint16(r) + if err != nil { + return err + } + d.TargetJobID, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.SourceJobID, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.HeaderCanary, err = rwu.ReadUint8(r) + if err != nil { + return err + } + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamID = steamid.SteamId(t1) + d.SessionID, err = rwu.ReadInt32(r) + return err +} + +type MsgHdrProtoBuf struct { + Msg EMsg + HeaderLength int32 + Proto *CMsgProtoBufHeader +} + +func NewMsgHdrProtoBuf() *MsgHdrProtoBuf { + return &MsgHdrProtoBuf{ + Msg: EMsg_Invalid, + Proto: new(CMsgProtoBufHeader), + } +} + +func (d *MsgHdrProtoBuf) Serialize(w io.Writer) error { + var err error + buf0, err := proto.Marshal(d.Proto) + if err != nil { + return err + } + d.HeaderLength = int32(len(buf0)) + err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask)) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.HeaderLength) + if err != nil { + return err + } + _, err = w.Write(buf0) + return err +} + +func (d *MsgHdrProtoBuf) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Msg = EMsg(uint32(t0) & EMsgMask) + d.HeaderLength, err = rwu.ReadInt32(r) + if err != nil { + return err + } + buf1 := make([]byte, d.HeaderLength, d.HeaderLength) + _, err = io.ReadFull(r, buf1) + if err != nil { + return err + } + err = proto.Unmarshal(buf1, d.Proto) + return err +} + +type MsgGCHdrProtoBuf struct { + Msg uint32 + HeaderLength int32 + Proto *CMsgProtoBufHeader +} + +func NewMsgGCHdrProtoBuf() *MsgGCHdrProtoBuf { + return &MsgGCHdrProtoBuf{ + Msg: 0, + Proto: new(CMsgProtoBufHeader), + } +} + +func (d *MsgGCHdrProtoBuf) Serialize(w io.Writer) error { + var err error + buf0, err := proto.Marshal(d.Proto) + if err != nil { + return err + } + d.HeaderLength = int32(len(buf0)) + err = binary.Write(w, binary.LittleEndian, EMsg(uint32(d.Msg)|ProtoMask)) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.HeaderLength) + if err != nil { + return err + } + _, err = w.Write(buf0) + return err +} + +func (d *MsgGCHdrProtoBuf) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint32(r) + if err != nil { + return err + } + d.Msg = uint32(t0) & EMsgMask + d.HeaderLength, err = rwu.ReadInt32(r) + if err != nil { + return err + } + buf1 := make([]byte, d.HeaderLength, d.HeaderLength) + _, err = io.ReadFull(r, buf1) + if err != nil { + return err + } + err = proto.Unmarshal(buf1, d.Proto) + return err +} + +type MsgGCHdr struct { + HeaderVersion uint16 + TargetJobID uint64 + SourceJobID uint64 +} + +func NewMsgGCHdr() *MsgGCHdr { + return &MsgGCHdr{ + HeaderVersion: 1, + TargetJobID: ^uint64(0), + SourceJobID: ^uint64(0), + } +} + +func (d *MsgGCHdr) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.HeaderVersion) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.TargetJobID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SourceJobID) + return err +} + +func (d *MsgGCHdr) Deserialize(r io.Reader) error { + var err error + d.HeaderVersion, err = rwu.ReadUint16(r) + if err != nil { + return err + } + d.TargetJobID, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.SourceJobID, err = rwu.ReadUint64(r) + return err +} + +type MsgClientJustStrings struct { +} + +func NewMsgClientJustStrings() *MsgClientJustStrings { + return &MsgClientJustStrings{} +} + +func (d *MsgClientJustStrings) GetEMsg() EMsg { + return EMsg_Invalid +} + +func (d *MsgClientJustStrings) Serialize(w io.Writer) error { + var err error + return err +} + +func (d *MsgClientJustStrings) Deserialize(r io.Reader) error { + var err error + return err +} + +type MsgClientGenericResponse struct { + Result EResult +} + +func NewMsgClientGenericResponse() *MsgClientGenericResponse { + return &MsgClientGenericResponse{} +} + +func (d *MsgClientGenericResponse) GetEMsg() EMsg { + return EMsg_Invalid +} + +func (d *MsgClientGenericResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + return err +} + +func (d *MsgClientGenericResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + d.Result = EResult(t0) + return err +} + +const MsgChannelEncryptRequest_PROTOCOL_VERSION uint32 = 1 + +type MsgChannelEncryptRequest struct { + ProtocolVersion uint32 + Universe EUniverse +} + +func NewMsgChannelEncryptRequest() *MsgChannelEncryptRequest { + return &MsgChannelEncryptRequest{ + ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION, + Universe: EUniverse_Invalid, + } +} + +func (d *MsgChannelEncryptRequest) GetEMsg() EMsg { + return EMsg_ChannelEncryptRequest +} + +func (d *MsgChannelEncryptRequest) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Universe) + return err +} + +func (d *MsgChannelEncryptRequest) Deserialize(r io.Reader) error { + var err error + d.ProtocolVersion, err = rwu.ReadUint32(r) + if err != nil { + return err + } + t0, err := rwu.ReadInt32(r) + d.Universe = EUniverse(t0) + return err +} + +type MsgChannelEncryptResponse struct { + ProtocolVersion uint32 + KeySize uint32 +} + +func NewMsgChannelEncryptResponse() *MsgChannelEncryptResponse { + return &MsgChannelEncryptResponse{ + ProtocolVersion: MsgChannelEncryptRequest_PROTOCOL_VERSION, + KeySize: 128, + } +} + +func (d *MsgChannelEncryptResponse) GetEMsg() EMsg { + return EMsg_ChannelEncryptResponse +} + +func (d *MsgChannelEncryptResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.ProtocolVersion) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.KeySize) + return err +} + +func (d *MsgChannelEncryptResponse) Deserialize(r io.Reader) error { + var err error + d.ProtocolVersion, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.KeySize, err = rwu.ReadUint32(r) + return err +} + +type MsgChannelEncryptResult struct { + Result EResult +} + +func NewMsgChannelEncryptResult() *MsgChannelEncryptResult { + return &MsgChannelEncryptResult{ + Result: EResult_Invalid, + } +} + +func (d *MsgChannelEncryptResult) GetEMsg() EMsg { + return EMsg_ChannelEncryptResult +} + +func (d *MsgChannelEncryptResult) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + return err +} + +func (d *MsgChannelEncryptResult) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + d.Result = EResult(t0) + return err +} + +type MsgClientNewLoginKey struct { + UniqueID uint32 + LoginKey []uint8 +} + +func NewMsgClientNewLoginKey() *MsgClientNewLoginKey { + return &MsgClientNewLoginKey{ + LoginKey: make([]uint8, 20, 20), + } +} + +func (d *MsgClientNewLoginKey) GetEMsg() EMsg { + return EMsg_ClientNewLoginKey +} + +func (d *MsgClientNewLoginKey) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.UniqueID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.LoginKey) + return err +} + +func (d *MsgClientNewLoginKey) Deserialize(r io.Reader) error { + var err error + d.UniqueID, err = rwu.ReadUint32(r) + if err != nil { + return err + } + err = binary.Read(r, binary.LittleEndian, d.LoginKey) + return err +} + +type MsgClientNewLoginKeyAccepted struct { + UniqueID uint32 +} + +func NewMsgClientNewLoginKeyAccepted() *MsgClientNewLoginKeyAccepted { + return &MsgClientNewLoginKeyAccepted{} +} + +func (d *MsgClientNewLoginKeyAccepted) GetEMsg() EMsg { + return EMsg_ClientNewLoginKeyAccepted +} + +func (d *MsgClientNewLoginKeyAccepted) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.UniqueID) + return err +} + +func (d *MsgClientNewLoginKeyAccepted) Deserialize(r io.Reader) error { + var err error + d.UniqueID, err = rwu.ReadUint32(r) + return err +} + +const ( + MsgClientLogon_ObfuscationMask uint32 = 0xBAADF00D + MsgClientLogon_CurrentProtocol uint32 = 65579 + MsgClientLogon_ProtocolVerMajorMask uint32 = 0xFFFF0000 + MsgClientLogon_ProtocolVerMinorMask uint32 = 0xFFFF + MsgClientLogon_ProtocolVerMinorMinGameServers uint16 = 4 + MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgMulti uint16 = 12 + MsgClientLogon_ProtocolVerMinorMinForSupportingEMsgClientEncryptPct uint16 = 14 + MsgClientLogon_ProtocolVerMinorMinForExtendedMsgHdr uint16 = 17 + MsgClientLogon_ProtocolVerMinorMinForCellId uint16 = 18 + MsgClientLogon_ProtocolVerMinorMinForSessionIDLast uint16 = 19 + MsgClientLogon_ProtocolVerMinorMinForServerAvailablityMsgs uint16 = 24 + MsgClientLogon_ProtocolVerMinorMinClients uint16 = 25 + MsgClientLogon_ProtocolVerMinorMinForOSType uint16 = 26 + MsgClientLogon_ProtocolVerMinorMinForCegApplyPESig uint16 = 27 + MsgClientLogon_ProtocolVerMinorMinForMarketingMessages2 uint16 = 27 + MsgClientLogon_ProtocolVerMinorMinForAnyProtoBufMessages uint16 = 28 + MsgClientLogon_ProtocolVerMinorMinForProtoBufLoggedOffMessage uint16 = 28 + MsgClientLogon_ProtocolVerMinorMinForProtoBufMultiMessages uint16 = 28 + MsgClientLogon_ProtocolVerMinorMinForSendingProtocolToUFS uint16 = 30 + MsgClientLogon_ProtocolVerMinorMinForMachineAuth uint16 = 33 + MsgClientLogon_ProtocolVerMinorMinForSessionIDLastAnon uint16 = 36 + MsgClientLogon_ProtocolVerMinorMinForEnhancedAppList uint16 = 40 + MsgClientLogon_ProtocolVerMinorMinForGzipMultiMessages uint16 = 43 +) + +type MsgClientLogon struct { +} + +func NewMsgClientLogon() *MsgClientLogon { + return &MsgClientLogon{} +} + +func (d *MsgClientLogon) GetEMsg() EMsg { + return EMsg_ClientLogon +} + +func (d *MsgClientLogon) Serialize(w io.Writer) error { + var err error + return err +} + +func (d *MsgClientLogon) Deserialize(r io.Reader) error { + var err error + return err +} + +type MsgClientVACBanStatus struct { + NumBans uint32 +} + +func NewMsgClientVACBanStatus() *MsgClientVACBanStatus { + return &MsgClientVACBanStatus{} +} + +func (d *MsgClientVACBanStatus) GetEMsg() EMsg { + return EMsg_ClientVACBanStatus +} + +func (d *MsgClientVACBanStatus) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.NumBans) + return err +} + +func (d *MsgClientVACBanStatus) Deserialize(r io.Reader) error { + var err error + d.NumBans, err = rwu.ReadUint32(r) + return err +} + +type MsgClientAppUsageEvent struct { + AppUsageEvent EAppUsageEvent + GameID uint64 + Offline uint16 +} + +func NewMsgClientAppUsageEvent() *MsgClientAppUsageEvent { + return &MsgClientAppUsageEvent{} +} + +func (d *MsgClientAppUsageEvent) GetEMsg() EMsg { + return EMsg_ClientAppUsageEvent +} + +func (d *MsgClientAppUsageEvent) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.AppUsageEvent) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.GameID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Offline) + return err +} + +func (d *MsgClientAppUsageEvent) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.AppUsageEvent = EAppUsageEvent(t0) + d.GameID, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.Offline, err = rwu.ReadUint16(r) + return err +} + +type MsgClientEmailAddrInfo struct { + PasswordStrength uint32 + FlagsAccountSecurityPolicy uint32 + Validated bool +} + +func NewMsgClientEmailAddrInfo() *MsgClientEmailAddrInfo { + return &MsgClientEmailAddrInfo{} +} + +func (d *MsgClientEmailAddrInfo) GetEMsg() EMsg { + return EMsg_ClientEmailAddrInfo +} + +func (d *MsgClientEmailAddrInfo) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.PasswordStrength) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.FlagsAccountSecurityPolicy) + if err != nil { + return err + } + err = rwu.WriteBool(w, d.Validated) + return err +} + +func (d *MsgClientEmailAddrInfo) Deserialize(r io.Reader) error { + var err error + d.PasswordStrength, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.FlagsAccountSecurityPolicy, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.Validated, err = rwu.ReadBool(r) + return err +} + +type MsgClientUpdateGuestPassesList struct { + Result EResult + CountGuestPassesToGive int32 + CountGuestPassesToRedeem int32 +} + +func NewMsgClientUpdateGuestPassesList() *MsgClientUpdateGuestPassesList { + return &MsgClientUpdateGuestPassesList{} +} + +func (d *MsgClientUpdateGuestPassesList) GetEMsg() EMsg { + return EMsg_ClientUpdateGuestPassesList +} + +func (d *MsgClientUpdateGuestPassesList) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToGive) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.CountGuestPassesToRedeem) + return err +} + +func (d *MsgClientUpdateGuestPassesList) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.CountGuestPassesToGive, err = rwu.ReadInt32(r) + if err != nil { + return err + } + d.CountGuestPassesToRedeem, err = rwu.ReadInt32(r) + return err +} + +type MsgClientRequestedClientStats struct { + CountStats int32 +} + +func NewMsgClientRequestedClientStats() *MsgClientRequestedClientStats { + return &MsgClientRequestedClientStats{} +} + +func (d *MsgClientRequestedClientStats) GetEMsg() EMsg { + return EMsg_ClientRequestedClientStats +} + +func (d *MsgClientRequestedClientStats) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.CountStats) + return err +} + +func (d *MsgClientRequestedClientStats) Deserialize(r io.Reader) error { + var err error + d.CountStats, err = rwu.ReadInt32(r) + return err +} + +type MsgClientP2PIntroducerMessage struct { + SteamID steamid.SteamId + RoutingType EIntroducerRouting + Data []uint8 + DataLen uint32 +} + +func NewMsgClientP2PIntroducerMessage() *MsgClientP2PIntroducerMessage { + return &MsgClientP2PIntroducerMessage{ + Data: make([]uint8, 1450, 1450), + } +} + +func (d *MsgClientP2PIntroducerMessage) GetEMsg() EMsg { + return EMsg_ClientP2PIntroducerMessage +} + +func (d *MsgClientP2PIntroducerMessage) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamID) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.RoutingType) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Data) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.DataLen) + return err +} + +func (d *MsgClientP2PIntroducerMessage) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamID = steamid.SteamId(t0) + t1, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.RoutingType = EIntroducerRouting(t1) + err = binary.Read(r, binary.LittleEndian, d.Data) + if err != nil { + return err + } + d.DataLen, err = rwu.ReadUint32(r) + return err +} + +type MsgClientOGSBeginSession struct { + AccountType uint8 + AccountId steamid.SteamId + AppId uint32 + TimeStarted uint32 +} + +func NewMsgClientOGSBeginSession() *MsgClientOGSBeginSession { + return &MsgClientOGSBeginSession{} +} + +func (d *MsgClientOGSBeginSession) GetEMsg() EMsg { + return EMsg_ClientOGSBeginSession +} + +func (d *MsgClientOGSBeginSession) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.AccountType) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.AccountId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.AppId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.TimeStarted) + return err +} + +func (d *MsgClientOGSBeginSession) Deserialize(r io.Reader) error { + var err error + d.AccountType, err = rwu.ReadUint8(r) + if err != nil { + return err + } + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.AccountId = steamid.SteamId(t0) + d.AppId, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.TimeStarted, err = rwu.ReadUint32(r) + return err +} + +type MsgClientOGSBeginSessionResponse struct { + Result EResult + CollectingAny bool + CollectingDetails bool + SessionId uint64 +} + +func NewMsgClientOGSBeginSessionResponse() *MsgClientOGSBeginSessionResponse { + return &MsgClientOGSBeginSessionResponse{} +} + +func (d *MsgClientOGSBeginSessionResponse) GetEMsg() EMsg { + return EMsg_ClientOGSBeginSessionResponse +} + +func (d *MsgClientOGSBeginSessionResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = rwu.WriteBool(w, d.CollectingAny) + if err != nil { + return err + } + err = rwu.WriteBool(w, d.CollectingDetails) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SessionId) + return err +} + +func (d *MsgClientOGSBeginSessionResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.CollectingAny, err = rwu.ReadBool(r) + if err != nil { + return err + } + d.CollectingDetails, err = rwu.ReadBool(r) + if err != nil { + return err + } + d.SessionId, err = rwu.ReadUint64(r) + return err +} + +type MsgClientOGSEndSession struct { + SessionId uint64 + TimeEnded uint32 + ReasonCode int32 + CountAttributes int32 +} + +func NewMsgClientOGSEndSession() *MsgClientOGSEndSession { + return &MsgClientOGSEndSession{} +} + +func (d *MsgClientOGSEndSession) GetEMsg() EMsg { + return EMsg_ClientOGSEndSession +} + +func (d *MsgClientOGSEndSession) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SessionId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.TimeEnded) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ReasonCode) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.CountAttributes) + return err +} + +func (d *MsgClientOGSEndSession) Deserialize(r io.Reader) error { + var err error + d.SessionId, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.TimeEnded, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.ReasonCode, err = rwu.ReadInt32(r) + if err != nil { + return err + } + d.CountAttributes, err = rwu.ReadInt32(r) + return err +} + +type MsgClientOGSEndSessionResponse struct { + Result EResult +} + +func NewMsgClientOGSEndSessionResponse() *MsgClientOGSEndSessionResponse { + return &MsgClientOGSEndSessionResponse{} +} + +func (d *MsgClientOGSEndSessionResponse) GetEMsg() EMsg { + return EMsg_ClientOGSEndSessionResponse +} + +func (d *MsgClientOGSEndSessionResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + return err +} + +func (d *MsgClientOGSEndSessionResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + d.Result = EResult(t0) + return err +} + +type MsgClientOGSWriteRow struct { + SessionId uint64 + CountAttributes int32 +} + +func NewMsgClientOGSWriteRow() *MsgClientOGSWriteRow { + return &MsgClientOGSWriteRow{} +} + +func (d *MsgClientOGSWriteRow) GetEMsg() EMsg { + return EMsg_ClientOGSWriteRow +} + +func (d *MsgClientOGSWriteRow) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SessionId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.CountAttributes) + return err +} + +func (d *MsgClientOGSWriteRow) Deserialize(r io.Reader) error { + var err error + d.SessionId, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.CountAttributes, err = rwu.ReadInt32(r) + return err +} + +type MsgClientGetFriendsWhoPlayGame struct { + GameId uint64 +} + +func NewMsgClientGetFriendsWhoPlayGame() *MsgClientGetFriendsWhoPlayGame { + return &MsgClientGetFriendsWhoPlayGame{} +} + +func (d *MsgClientGetFriendsWhoPlayGame) GetEMsg() EMsg { + return EMsg_ClientGetFriendsWhoPlayGame +} + +func (d *MsgClientGetFriendsWhoPlayGame) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.GameId) + return err +} + +func (d *MsgClientGetFriendsWhoPlayGame) Deserialize(r io.Reader) error { + var err error + d.GameId, err = rwu.ReadUint64(r) + return err +} + +type MsgClientGetFriendsWhoPlayGameResponse struct { + Result EResult + GameId uint64 + CountFriends uint32 +} + +func NewMsgClientGetFriendsWhoPlayGameResponse() *MsgClientGetFriendsWhoPlayGameResponse { + return &MsgClientGetFriendsWhoPlayGameResponse{} +} + +func (d *MsgClientGetFriendsWhoPlayGameResponse) GetEMsg() EMsg { + return EMsg_ClientGetFriendsWhoPlayGameResponse +} + +func (d *MsgClientGetFriendsWhoPlayGameResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.GameId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.CountFriends) + return err +} + +func (d *MsgClientGetFriendsWhoPlayGameResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.GameId, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.CountFriends, err = rwu.ReadUint32(r) + return err +} + +type MsgGSPerformHardwareSurvey struct { + Flags uint32 +} + +func NewMsgGSPerformHardwareSurvey() *MsgGSPerformHardwareSurvey { + return &MsgGSPerformHardwareSurvey{} +} + +func (d *MsgGSPerformHardwareSurvey) GetEMsg() EMsg { + return EMsg_GSPerformHardwareSurvey +} + +func (d *MsgGSPerformHardwareSurvey) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Flags) + return err +} + +func (d *MsgGSPerformHardwareSurvey) Deserialize(r io.Reader) error { + var err error + d.Flags, err = rwu.ReadUint32(r) + return err +} + +type MsgGSGetPlayStatsResponse struct { + Result EResult + Rank int32 + LifetimeConnects uint32 + LifetimeMinutesPlayed uint32 +} + +func NewMsgGSGetPlayStatsResponse() *MsgGSGetPlayStatsResponse { + return &MsgGSGetPlayStatsResponse{} +} + +func (d *MsgGSGetPlayStatsResponse) GetEMsg() EMsg { + return EMsg_GSGetPlayStatsResponse +} + +func (d *MsgGSGetPlayStatsResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Rank) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.LifetimeConnects) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.LifetimeMinutesPlayed) + return err +} + +func (d *MsgGSGetPlayStatsResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.Rank, err = rwu.ReadInt32(r) + if err != nil { + return err + } + d.LifetimeConnects, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.LifetimeMinutesPlayed, err = rwu.ReadUint32(r) + return err +} + +type MsgGSGetReputationResponse struct { + Result EResult + ReputationScore uint32 + Banned bool + BannedIp uint32 + BannedPort uint16 + BannedGameId uint64 + TimeBanExpires uint32 +} + +func NewMsgGSGetReputationResponse() *MsgGSGetReputationResponse { + return &MsgGSGetReputationResponse{} +} + +func (d *MsgGSGetReputationResponse) GetEMsg() EMsg { + return EMsg_GSGetReputationResponse +} + +func (d *MsgGSGetReputationResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ReputationScore) + if err != nil { + return err + } + err = rwu.WriteBool(w, d.Banned) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.BannedIp) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.BannedPort) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.BannedGameId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.TimeBanExpires) + return err +} + +func (d *MsgGSGetReputationResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.ReputationScore, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.Banned, err = rwu.ReadBool(r) + if err != nil { + return err + } + d.BannedIp, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.BannedPort, err = rwu.ReadUint16(r) + if err != nil { + return err + } + d.BannedGameId, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.TimeBanExpires, err = rwu.ReadUint32(r) + return err +} + +type MsgGSDeny struct { + SteamId steamid.SteamId + DenyReason EDenyReason +} + +func NewMsgGSDeny() *MsgGSDeny { + return &MsgGSDeny{} +} + +func (d *MsgGSDeny) GetEMsg() EMsg { + return EMsg_GSDeny +} + +func (d *MsgGSDeny) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.DenyReason) + return err +} + +func (d *MsgGSDeny) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamId = steamid.SteamId(t0) + t1, err := rwu.ReadInt32(r) + d.DenyReason = EDenyReason(t1) + return err +} + +type MsgGSApprove struct { + SteamId steamid.SteamId +} + +func NewMsgGSApprove() *MsgGSApprove { + return &MsgGSApprove{} +} + +func (d *MsgGSApprove) GetEMsg() EMsg { + return EMsg_GSApprove +} + +func (d *MsgGSApprove) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamId) + return err +} + +func (d *MsgGSApprove) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamId = steamid.SteamId(t0) + return err +} + +type MsgGSKick struct { + SteamId steamid.SteamId + DenyReason EDenyReason + WaitTilMapChange int32 +} + +func NewMsgGSKick() *MsgGSKick { + return &MsgGSKick{} +} + +func (d *MsgGSKick) GetEMsg() EMsg { + return EMsg_GSKick +} + +func (d *MsgGSKick) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.DenyReason) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.WaitTilMapChange) + return err +} + +func (d *MsgGSKick) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamId = steamid.SteamId(t0) + t1, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.DenyReason = EDenyReason(t1) + d.WaitTilMapChange, err = rwu.ReadInt32(r) + return err +} + +type MsgGSGetUserGroupStatus struct { + SteamIdUser steamid.SteamId + SteamIdGroup steamid.SteamId +} + +func NewMsgGSGetUserGroupStatus() *MsgGSGetUserGroupStatus { + return &MsgGSGetUserGroupStatus{} +} + +func (d *MsgGSGetUserGroupStatus) GetEMsg() EMsg { + return EMsg_GSGetUserGroupStatus +} + +func (d *MsgGSGetUserGroupStatus) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdUser) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup) + return err +} + +func (d *MsgGSGetUserGroupStatus) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdUser = steamid.SteamId(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdGroup = steamid.SteamId(t1) + return err +} + +type MsgGSGetUserGroupStatusResponse struct { + SteamIdUser steamid.SteamId + SteamIdGroup steamid.SteamId + ClanRelationship EClanRelationship + ClanRank EClanRank +} + +func NewMsgGSGetUserGroupStatusResponse() *MsgGSGetUserGroupStatusResponse { + return &MsgGSGetUserGroupStatusResponse{} +} + +func (d *MsgGSGetUserGroupStatusResponse) GetEMsg() EMsg { + return EMsg_GSGetUserGroupStatusResponse +} + +func (d *MsgGSGetUserGroupStatusResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdUser) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdGroup) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ClanRelationship) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ClanRank) + return err +} + +func (d *MsgGSGetUserGroupStatusResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdUser = steamid.SteamId(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdGroup = steamid.SteamId(t1) + t2, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.ClanRelationship = EClanRelationship(t2) + t3, err := rwu.ReadInt32(r) + d.ClanRank = EClanRank(t3) + return err +} + +type MsgClientJoinChat struct { + SteamIdChat steamid.SteamId + IsVoiceSpeaker bool +} + +func NewMsgClientJoinChat() *MsgClientJoinChat { + return &MsgClientJoinChat{} +} + +func (d *MsgClientJoinChat) GetEMsg() EMsg { + return EMsg_ClientJoinChat +} + +func (d *MsgClientJoinChat) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) + if err != nil { + return err + } + err = rwu.WriteBool(w, d.IsVoiceSpeaker) + return err +} + +func (d *MsgClientJoinChat) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChat = steamid.SteamId(t0) + d.IsVoiceSpeaker, err = rwu.ReadBool(r) + return err +} + +type MsgClientChatEnter struct { + SteamIdChat steamid.SteamId + SteamIdFriend steamid.SteamId + ChatRoomType EChatRoomType + SteamIdOwner steamid.SteamId + SteamIdClan steamid.SteamId + ChatFlags uint8 + EnterResponse EChatRoomEnterResponse + NumMembers int32 +} + +func NewMsgClientChatEnter() *MsgClientChatEnter { + return &MsgClientChatEnter{} +} + +func (d *MsgClientChatEnter) GetEMsg() EMsg { + return EMsg_ClientChatEnter +} + +func (d *MsgClientChatEnter) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ChatRoomType) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdOwner) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdClan) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ChatFlags) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.EnterResponse) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.NumMembers) + return err +} + +func (d *MsgClientChatEnter) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChat = steamid.SteamId(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdFriend = steamid.SteamId(t1) + t2, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.ChatRoomType = EChatRoomType(t2) + t3, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdOwner = steamid.SteamId(t3) + t4, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdClan = steamid.SteamId(t4) + d.ChatFlags, err = rwu.ReadUint8(r) + if err != nil { + return err + } + t5, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.EnterResponse = EChatRoomEnterResponse(t5) + d.NumMembers, err = rwu.ReadInt32(r) + return err +} + +type MsgClientChatMsg struct { + SteamIdChatter steamid.SteamId + SteamIdChatRoom steamid.SteamId + ChatMsgType EChatEntryType +} + +func NewMsgClientChatMsg() *MsgClientChatMsg { + return &MsgClientChatMsg{} +} + +func (d *MsgClientChatMsg) GetEMsg() EMsg { + return EMsg_ClientChatMsg +} + +func (d *MsgClientChatMsg) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdChatter) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdChatRoom) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ChatMsgType) + return err +} + +func (d *MsgClientChatMsg) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChatter = steamid.SteamId(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChatRoom = steamid.SteamId(t1) + t2, err := rwu.ReadInt32(r) + d.ChatMsgType = EChatEntryType(t2) + return err +} + +type MsgClientChatMemberInfo struct { + SteamIdChat steamid.SteamId + Type EChatInfoType +} + +func NewMsgClientChatMemberInfo() *MsgClientChatMemberInfo { + return &MsgClientChatMemberInfo{} +} + +func (d *MsgClientChatMemberInfo) GetEMsg() EMsg { + return EMsg_ClientChatMemberInfo +} + +func (d *MsgClientChatMemberInfo) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Type) + return err +} + +func (d *MsgClientChatMemberInfo) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChat = steamid.SteamId(t0) + t1, err := rwu.ReadInt32(r) + d.Type = EChatInfoType(t1) + return err +} + +type MsgClientChatAction struct { + SteamIdChat steamid.SteamId + SteamIdUserToActOn steamid.SteamId + ChatAction EChatAction +} + +func NewMsgClientChatAction() *MsgClientChatAction { + return &MsgClientChatAction{} +} + +func (d *MsgClientChatAction) GetEMsg() EMsg { + return EMsg_ClientChatAction +} + +func (d *MsgClientChatAction) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdUserToActOn) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ChatAction) + return err +} + +func (d *MsgClientChatAction) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChat = steamid.SteamId(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdUserToActOn = steamid.SteamId(t1) + t2, err := rwu.ReadInt32(r) + d.ChatAction = EChatAction(t2) + return err +} + +type MsgClientChatActionResult struct { + SteamIdChat steamid.SteamId + SteamIdUserActedOn steamid.SteamId + ChatAction EChatAction + ActionResult EChatActionResult +} + +func NewMsgClientChatActionResult() *MsgClientChatActionResult { + return &MsgClientChatActionResult{} +} + +func (d *MsgClientChatActionResult) GetEMsg() EMsg { + return EMsg_ClientChatActionResult +} + +func (d *MsgClientChatActionResult) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdUserActedOn) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ChatAction) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ActionResult) + return err +} + +func (d *MsgClientChatActionResult) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChat = steamid.SteamId(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdUserActedOn = steamid.SteamId(t1) + t2, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.ChatAction = EChatAction(t2) + t3, err := rwu.ReadInt32(r) + d.ActionResult = EChatActionResult(t3) + return err +} + +type MsgClientChatRoomInfo struct { + SteamIdChat steamid.SteamId + Type EChatInfoType +} + +func NewMsgClientChatRoomInfo() *MsgClientChatRoomInfo { + return &MsgClientChatRoomInfo{} +} + +func (d *MsgClientChatRoomInfo) GetEMsg() EMsg { + return EMsg_ClientChatRoomInfo +} + +func (d *MsgClientChatRoomInfo) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Type) + return err +} + +func (d *MsgClientChatRoomInfo) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChat = steamid.SteamId(t0) + t1, err := rwu.ReadInt32(r) + d.Type = EChatInfoType(t1) + return err +} + +type MsgClientGetNumberOfCurrentPlayers struct { + GameID uint64 +} + +func NewMsgClientGetNumberOfCurrentPlayers() *MsgClientGetNumberOfCurrentPlayers { + return &MsgClientGetNumberOfCurrentPlayers{} +} + +func (d *MsgClientGetNumberOfCurrentPlayers) GetEMsg() EMsg { + return EMsg_ClientGetNumberOfCurrentPlayers +} + +func (d *MsgClientGetNumberOfCurrentPlayers) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.GameID) + return err +} + +func (d *MsgClientGetNumberOfCurrentPlayers) Deserialize(r io.Reader) error { + var err error + d.GameID, err = rwu.ReadUint64(r) + return err +} + +type MsgClientGetNumberOfCurrentPlayersResponse struct { + Result EResult + NumPlayers uint32 +} + +func NewMsgClientGetNumberOfCurrentPlayersResponse() *MsgClientGetNumberOfCurrentPlayersResponse { + return &MsgClientGetNumberOfCurrentPlayersResponse{} +} + +func (d *MsgClientGetNumberOfCurrentPlayersResponse) GetEMsg() EMsg { + return EMsg_ClientGetNumberOfCurrentPlayersResponse +} + +func (d *MsgClientGetNumberOfCurrentPlayersResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.NumPlayers) + return err +} + +func (d *MsgClientGetNumberOfCurrentPlayersResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.NumPlayers, err = rwu.ReadUint32(r) + return err +} + +type MsgClientSetIgnoreFriend struct { + MySteamId steamid.SteamId + SteamIdFriend steamid.SteamId + Ignore uint8 +} + +func NewMsgClientSetIgnoreFriend() *MsgClientSetIgnoreFriend { + return &MsgClientSetIgnoreFriend{} +} + +func (d *MsgClientSetIgnoreFriend) GetEMsg() EMsg { + return EMsg_ClientSetIgnoreFriend +} + +func (d *MsgClientSetIgnoreFriend) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.MySteamId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdFriend) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Ignore) + return err +} + +func (d *MsgClientSetIgnoreFriend) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.MySteamId = steamid.SteamId(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdFriend = steamid.SteamId(t1) + d.Ignore, err = rwu.ReadUint8(r) + return err +} + +type MsgClientSetIgnoreFriendResponse struct { + Unknown uint64 + Result EResult +} + +func NewMsgClientSetIgnoreFriendResponse() *MsgClientSetIgnoreFriendResponse { + return &MsgClientSetIgnoreFriendResponse{} +} + +func (d *MsgClientSetIgnoreFriendResponse) GetEMsg() EMsg { + return EMsg_ClientSetIgnoreFriendResponse +} + +func (d *MsgClientSetIgnoreFriendResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Unknown) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Result) + return err +} + +func (d *MsgClientSetIgnoreFriendResponse) Deserialize(r io.Reader) error { + var err error + d.Unknown, err = rwu.ReadUint64(r) + if err != nil { + return err + } + t0, err := rwu.ReadInt32(r) + d.Result = EResult(t0) + return err +} + +type MsgClientLoggedOff struct { + Result EResult + SecMinReconnectHint int32 + SecMaxReconnectHint int32 +} + +func NewMsgClientLoggedOff() *MsgClientLoggedOff { + return &MsgClientLoggedOff{} +} + +func (d *MsgClientLoggedOff) GetEMsg() EMsg { + return EMsg_ClientLoggedOff +} + +func (d *MsgClientLoggedOff) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SecMinReconnectHint) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SecMaxReconnectHint) + return err +} + +func (d *MsgClientLoggedOff) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.SecMinReconnectHint, err = rwu.ReadInt32(r) + if err != nil { + return err + } + d.SecMaxReconnectHint, err = rwu.ReadInt32(r) + return err +} + +type MsgClientLogOnResponse struct { + Result EResult + OutOfGameHeartbeatRateSec int32 + InGameHeartbeatRateSec int32 + ClientSuppliedSteamId steamid.SteamId + IpPublic uint32 + ServerRealTime uint32 +} + +func NewMsgClientLogOnResponse() *MsgClientLogOnResponse { + return &MsgClientLogOnResponse{} +} + +func (d *MsgClientLogOnResponse) GetEMsg() EMsg { + return EMsg_ClientLogOnResponse +} + +func (d *MsgClientLogOnResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.OutOfGameHeartbeatRateSec) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.InGameHeartbeatRateSec) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ClientSuppliedSteamId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.IpPublic) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ServerRealTime) + return err +} + +func (d *MsgClientLogOnResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + d.OutOfGameHeartbeatRateSec, err = rwu.ReadInt32(r) + if err != nil { + return err + } + d.InGameHeartbeatRateSec, err = rwu.ReadInt32(r) + if err != nil { + return err + } + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.ClientSuppliedSteamId = steamid.SteamId(t1) + d.IpPublic, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.ServerRealTime, err = rwu.ReadUint32(r) + return err +} + +type MsgClientSendGuestPass struct { + GiftId uint64 + GiftType uint8 + AccountId uint32 +} + +func NewMsgClientSendGuestPass() *MsgClientSendGuestPass { + return &MsgClientSendGuestPass{} +} + +func (d *MsgClientSendGuestPass) GetEMsg() EMsg { + return EMsg_ClientSendGuestPass +} + +func (d *MsgClientSendGuestPass) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.GiftId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.GiftType) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.AccountId) + return err +} + +func (d *MsgClientSendGuestPass) Deserialize(r io.Reader) error { + var err error + d.GiftId, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.GiftType, err = rwu.ReadUint8(r) + if err != nil { + return err + } + d.AccountId, err = rwu.ReadUint32(r) + return err +} + +type MsgClientSendGuestPassResponse struct { + Result EResult +} + +func NewMsgClientSendGuestPassResponse() *MsgClientSendGuestPassResponse { + return &MsgClientSendGuestPassResponse{} +} + +func (d *MsgClientSendGuestPassResponse) GetEMsg() EMsg { + return EMsg_ClientSendGuestPassResponse +} + +func (d *MsgClientSendGuestPassResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + return err +} + +func (d *MsgClientSendGuestPassResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + d.Result = EResult(t0) + return err +} + +type MsgClientServerUnavailable struct { + JobidSent uint64 + EMsgSent uint32 + EServerTypeUnavailable EServerType +} + +func NewMsgClientServerUnavailable() *MsgClientServerUnavailable { + return &MsgClientServerUnavailable{} +} + +func (d *MsgClientServerUnavailable) GetEMsg() EMsg { + return EMsg_ClientServerUnavailable +} + +func (d *MsgClientServerUnavailable) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.JobidSent) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.EMsgSent) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.EServerTypeUnavailable) + return err +} + +func (d *MsgClientServerUnavailable) Deserialize(r io.Reader) error { + var err error + d.JobidSent, err = rwu.ReadUint64(r) + if err != nil { + return err + } + d.EMsgSent, err = rwu.ReadUint32(r) + if err != nil { + return err + } + t0, err := rwu.ReadInt32(r) + d.EServerTypeUnavailable = EServerType(t0) + return err +} + +type MsgClientCreateChat struct { + ChatRoomType EChatRoomType + GameId uint64 + SteamIdClan steamid.SteamId + PermissionOfficer EChatPermission + PermissionMember EChatPermission + PermissionAll EChatPermission + MembersMax uint32 + ChatFlags uint8 + SteamIdFriendChat steamid.SteamId + SteamIdInvited steamid.SteamId +} + +func NewMsgClientCreateChat() *MsgClientCreateChat { + return &MsgClientCreateChat{} +} + +func (d *MsgClientCreateChat) GetEMsg() EMsg { + return EMsg_ClientCreateChat +} + +func (d *MsgClientCreateChat) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.ChatRoomType) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.GameId) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdClan) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.PermissionOfficer) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.PermissionMember) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.PermissionAll) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.MembersMax) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ChatFlags) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdInvited) + return err +} + +func (d *MsgClientCreateChat) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.ChatRoomType = EChatRoomType(t0) + d.GameId, err = rwu.ReadUint64(r) + if err != nil { + return err + } + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdClan = steamid.SteamId(t1) + t2, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.PermissionOfficer = EChatPermission(t2) + t3, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.PermissionMember = EChatPermission(t3) + t4, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.PermissionAll = EChatPermission(t4) + d.MembersMax, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.ChatFlags, err = rwu.ReadUint8(r) + if err != nil { + return err + } + t5, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdFriendChat = steamid.SteamId(t5) + t6, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdInvited = steamid.SteamId(t6) + return err +} + +type MsgClientCreateChatResponse struct { + Result EResult + SteamIdChat steamid.SteamId + ChatRoomType EChatRoomType + SteamIdFriendChat steamid.SteamId +} + +func NewMsgClientCreateChatResponse() *MsgClientCreateChatResponse { + return &MsgClientCreateChatResponse{} +} + +func (d *MsgClientCreateChatResponse) GetEMsg() EMsg { + return EMsg_ClientCreateChatResponse +} + +func (d *MsgClientCreateChatResponse) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.Result) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdChat) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.ChatRoomType) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.SteamIdFriendChat) + return err +} + +func (d *MsgClientCreateChatResponse) Deserialize(r io.Reader) error { + var err error + t0, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.Result = EResult(t0) + t1, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdChat = steamid.SteamId(t1) + t2, err := rwu.ReadInt32(r) + if err != nil { + return err + } + d.ChatRoomType = EChatRoomType(t2) + t3, err := rwu.ReadUint64(r) + if err != nil { + return err + } + d.SteamIdFriendChat = steamid.SteamId(t3) + return err +} + +type MsgClientMarketingMessageUpdate2 struct { + MarketingMessageUpdateTime uint32 + Count uint32 +} + +func NewMsgClientMarketingMessageUpdate2() *MsgClientMarketingMessageUpdate2 { + return &MsgClientMarketingMessageUpdate2{} +} + +func (d *MsgClientMarketingMessageUpdate2) GetEMsg() EMsg { + return EMsg_ClientMarketingMessageUpdate2 +} + +func (d *MsgClientMarketingMessageUpdate2) Serialize(w io.Writer) error { + var err error + err = binary.Write(w, binary.LittleEndian, d.MarketingMessageUpdateTime) + if err != nil { + return err + } + err = binary.Write(w, binary.LittleEndian, d.Count) + return err +} + +func (d *MsgClientMarketingMessageUpdate2) Deserialize(r io.Reader) error { + var err error + d.MarketingMessageUpdateTime, err = rwu.ReadUint32(r) + if err != nil { + return err + } + d.Count, err = rwu.ReadUint32(r) + return err +} diff --git a/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/steamlang.go b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/steamlang.go new file mode 100644 index 00000000..795aa468 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/protocol/steamlang/steamlang.go @@ -0,0 +1,17 @@ +/* +Contains code generated from SteamKit's SteamLanguage data. +*/ +package steamlang + +const ( + ProtoMask uint32 = 0x80000000 + EMsgMask = ^ProtoMask +) + +func NewEMsg(e uint32) EMsg { + return EMsg(e & EMsgMask) +} + +func IsProto(e uint32) bool { + return e&ProtoMask > 0 +} diff --git a/vendor/github.com/Philipp15b/go-steam/rwu/rwu.go b/vendor/github.com/Philipp15b/go-steam/rwu/rwu.go new file mode 100644 index 00000000..f5ee4385 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/rwu/rwu.go @@ -0,0 +1,97 @@ +// Utilities for reading and writing of binary data +package rwu + +import ( + "encoding/binary" + "io" +) + +func ReadBool(r io.Reader) (bool, error) { + var c uint8 + err := binary.Read(r, binary.LittleEndian, &c) + return c != 0, err +} + +func ReadUint8(r io.Reader) (uint8, error) { + var c uint8 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadUint16(r io.Reader) (uint16, error) { + var c uint16 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadUint32(r io.Reader) (uint32, error) { + var c uint32 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadUint64(r io.Reader) (uint64, error) { + var c uint64 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadInt8(r io.Reader) (int8, error) { + var c int8 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadInt16(r io.Reader) (int16, error) { + var c int16 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadInt32(r io.Reader) (int32, error) { + var c int32 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadInt64(r io.Reader) (int64, error) { + var c int64 + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadString(r io.Reader) (string, error) { + c := make([]byte, 0) + var err error + for { + var b byte + err = binary.Read(r, binary.LittleEndian, &b) + if b == byte(0x0) || err != nil { + break + } + c = append(c, b) + } + return string(c), err +} + +func ReadByte(r io.Reader) (byte, error) { + var c byte + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func ReadBytes(r io.Reader, num int32) ([]byte, error) { + c := make([]byte, num) + err := binary.Read(r, binary.LittleEndian, &c) + return c, err +} + +func WriteBool(w io.Writer, b bool) error { + var err error + if b { + _, err = w.Write([]byte{1}) + } else { + _, err = w.Write([]byte{0}) + } + return err +} diff --git a/vendor/github.com/Philipp15b/go-steam/servers.go b/vendor/github.com/Philipp15b/go-steam/servers.go new file mode 100644 index 00000000..a0763d42 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/servers.go @@ -0,0 +1,144 @@ +package steam + +import ( + "math/rand" + "time" + + "github.com/Philipp15b/go-steam/netutil" +) + +// CMServers contains a list of worlwide servers +var CMServers = [][]string{ + { // North American Servers + // Chicago + "162.254.193.44:27018", + "162.254.193.44:27019", + "162.254.193.44:27020", + "162.254.193.44:27021", + "162.254.193.45:27017", + "162.254.193.45:27018", + "162.254.193.45:27019", + "162.254.193.45:27021", + "162.254.193.46:27017", + "162.254.193.46:27018", + "162.254.193.46:27019", + "162.254.193.46:27020", + "162.254.193.46:27021", + "162.254.193.47:27019", + "162.254.193.47:27020", + + // Ashburn + "208.78.164.9:27017", + "208.78.164.9:27018", + "208.78.164.9:27019", + "208.78.164.10:27017", + "208.78.164.10:27018", + "208.78.164.10:27019", + "208.78.164.11:27017", + "208.78.164.11:27018", + "208.78.164.11:27019", + "208.78.164.12:27017", + "208.78.164.12:27018", + "208.78.164.12:27019", + "208.78.164.13:27017", + "208.78.164.13:27018", + "208.78.164.13:27019", + "208.78.164.14:27017", + "208.78.164.14:27018", + "208.78.164.14:27019", + }, + { // Europe Servers + // Luxembourg + "146.66.152.10:27017", + "146.66.152.10:27018", + "146.66.152.10:27019", + "146.66.152.10:27020", + "146.66.152.11:27017", + "146.66.152.11:27018", + "146.66.152.11:27019", + "146.66.152.11:27020", + + // Poland + "155.133.242.8:27017", + "155.133.242.8:27018", + "155.133.242.8:27019", + "155.133.242.8:27020", + "155.133.242.9:27017", + "155.133.242.9:27018", + "155.133.242.9:27019", + "155.133.242.9:27020", + + // Vienna + "146.66.155.8:27017", + "146.66.155.8:27018", + "146.66.155.8:27019", + "146.66.155.8:27020", + "185.25.182.10:27017", + "185.25.182.10:27018", + "185.25.182.10:27019", + "185.25.182.10:27020", + + // London + "162.254.196.40:27017", + "162.254.196.40:27018", + "162.254.196.40:27019", + "162.254.196.40:27020", + "162.254.196.40:27021", + "162.254.196.41:27017", + "162.254.196.41:27018", + "162.254.196.41:27019", + "162.254.196.41:27020", + "162.254.196.41:27021", + "162.254.196.42:27017", + "162.254.196.42:27018", + "162.254.196.42:27019", + "162.254.196.42:27020", + "162.254.196.42:27021", + "162.254.196.43:27017", + "162.254.196.43:27018", + "162.254.196.43:27019", + "162.254.196.43:27020", + "162.254.196.43:27021", + + // Stockholm + "185.25.180.14:27017", + "185.25.180.14:27018", + "185.25.180.14:27019", + "185.25.180.14:27020", + "185.25.180.15:27017", + "185.25.180.15:27018", + "185.25.180.15:27019", + "185.25.180.15:27020", + }, +} + +// GetRandomCM returns back a random server anywhere +func GetRandomCM() *netutil.PortAddr { + rng := rand.New(rand.NewSource(time.Now().UnixNano())) + servers := append(CMServers[0], CMServers[1]...) + addr := netutil.ParsePortAddr(servers[rng.Int31n(int32(len(servers)))]) + if addr == nil { + panic("invalid address in CMServers slice") + } + return addr +} + +// GetRandomNorthAmericaCM returns back a random server in north america +func GetRandomNorthAmericaCM() *netutil.PortAddr { + rng := rand.New(rand.NewSource(time.Now().UnixNano())) + addr := netutil.ParsePortAddr(CMServers[0][rng.Int31n(int32(len(CMServers[0])))]) + if addr == nil { + panic("invalid address in CMServers slice") + } + return addr +} + +// GetRandomEuropeCM returns back a random server in europe +func GetRandomEuropeCM() *netutil.PortAddr { + rng := rand.New(rand.NewSource(time.Now().UnixNano())) + addr := netutil.ParsePortAddr(CMServers[1][rng.Int31n(int32(len(CMServers[1])))]) + if addr == nil { + panic("invalid address in CMServers slice") + } + return addr +} diff --git a/vendor/github.com/Philipp15b/go-steam/social.go b/vendor/github.com/Philipp15b/go-steam/social.go new file mode 100644 index 00000000..c61899cf --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/social.go @@ -0,0 +1,624 @@ +package steam + +import ( + "bytes" + "encoding/binary" + "encoding/hex" + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/rwu" + "github.com/Philipp15b/go-steam/socialcache" + . "github.com/Philipp15b/go-steam/steamid" + "github.com/golang/protobuf/proto" + "io" + "sync" + "time" +) + +// Provides access to social aspects of Steam. +type Social struct { + mutex sync.RWMutex + + name string + avatar string + personaState EPersonaState + + Friends *socialcache.FriendsList + Groups *socialcache.GroupsList + Chats *socialcache.ChatsList + + client *Client +} + +func newSocial(client *Client) *Social { + return &Social{ + Friends: socialcache.NewFriendsList(), + Groups: socialcache.NewGroupsList(), + Chats: socialcache.NewChatsList(), + client: client, + } +} + +// Gets the local user's avatar +func (s *Social) GetAvatar() string { + s.mutex.RLock() + defer s.mutex.RUnlock() + return s.avatar +} + +// Gets the local user's persona name +func (s *Social) GetPersonaName() string { + s.mutex.RLock() + defer s.mutex.RUnlock() + return s.name +} + +// Sets the local user's persona name and broadcasts it over the network +func (s *Social) SetPersonaName(name string) { + s.mutex.Lock() + defer s.mutex.Unlock() + s.name = name + s.client.Write(NewClientMsgProtobuf(EMsg_ClientChangeStatus, &CMsgClientChangeStatus{ + PersonaState: proto.Uint32(uint32(s.personaState)), + PlayerName: proto.String(name), + })) +} + +// Gets the local user's persona state +func (s *Social) GetPersonaState() EPersonaState { + s.mutex.RLock() + defer s.mutex.RUnlock() + return s.personaState +} + +// Sets the local user's persona state and broadcasts it over the network +func (s *Social) SetPersonaState(state EPersonaState) { + s.mutex.Lock() + defer s.mutex.Unlock() + s.personaState = state + s.client.Write(NewClientMsgProtobuf(EMsg_ClientChangeStatus, &CMsgClientChangeStatus{ + PersonaState: proto.Uint32(uint32(state)), + })) +} + +// Sends a chat message to ether a room or friend +func (s *Social) SendMessage(to SteamId, entryType EChatEntryType, message string) { + //Friend + if to.GetAccountType() == int32(EAccountType_Individual) || to.GetAccountType() == int32(EAccountType_ConsoleUser) { + s.client.Write(NewClientMsgProtobuf(EMsg_ClientFriendMsg, &CMsgClientFriendMsg{ + Steamid: proto.Uint64(to.ToUint64()), + ChatEntryType: proto.Int32(int32(entryType)), + Message: []byte(message), + })) + //Chat room + } else if to.GetAccountType() == int32(EAccountType_Clan) || to.GetAccountType() == int32(EAccountType_Chat) { + chatId := to.ClanToChat() + s.client.Write(NewClientMsg(&MsgClientChatMsg{ + ChatMsgType: entryType, + SteamIdChatRoom: chatId, + SteamIdChatter: s.client.SteamId(), + }, []byte(message))) + } +} + +// Adds a friend to your friends list or accepts a friend. You'll receive a FriendStateEvent +// for every new/changed friend +func (s *Social) AddFriend(id SteamId) { + s.client.Write(NewClientMsgProtobuf(EMsg_ClientAddFriend, &CMsgClientAddFriend{ + SteamidToAdd: proto.Uint64(id.ToUint64()), + })) +} + +// Removes a friend from your friends list +func (s *Social) RemoveFriend(id SteamId) { + s.client.Write(NewClientMsgProtobuf(EMsg_ClientRemoveFriend, &CMsgClientRemoveFriend{ + Friendid: proto.Uint64(id.ToUint64()), + })) +} + +// Ignores or unignores a friend on Steam +func (s *Social) IgnoreFriend(id SteamId, setIgnore bool) { + ignore := uint8(1) //True + if !setIgnore { + ignore = uint8(0) //False + } + s.client.Write(NewClientMsg(&MsgClientSetIgnoreFriend{ + MySteamId: s.client.SteamId(), + SteamIdFriend: id, + Ignore: ignore, + }, make([]byte, 0))) +} + +// Requests persona state for a list of specified SteamIds +func (s *Social) RequestFriendListInfo(ids []SteamId, requestedInfo EClientPersonaStateFlag) { + var friends []uint64 + for _, id := range ids { + friends = append(friends, id.ToUint64()) + } + s.client.Write(NewClientMsgProtobuf(EMsg_ClientRequestFriendData, &CMsgClientRequestFriendData{ + PersonaStateRequested: proto.Uint32(uint32(requestedInfo)), + Friends: friends, + })) +} + +// Requests persona state for a specified SteamId +func (s *Social) RequestFriendInfo(id SteamId, requestedInfo EClientPersonaStateFlag) { + s.RequestFriendListInfo([]SteamId{id}, requestedInfo) +} + +// Requests profile information for a specified SteamId +func (s *Social) RequestProfileInfo(id SteamId) { + s.client.Write(NewClientMsgProtobuf(EMsg_ClientFriendProfileInfo, &CMsgClientFriendProfileInfo{ + SteamidFriend: proto.Uint64(id.ToUint64()), + })) +} + +// Requests all offline messages and marks them as read +func (s *Social) RequestOfflineMessages() { + s.client.Write(NewClientMsgProtobuf(EMsg_ClientFSGetFriendMessageHistoryForOfflineMessages, &CMsgClientFSGetFriendMessageHistoryForOfflineMessages{})) +} + +// Attempts to join a chat room +func (s *Social) JoinChat(id SteamId) { + chatId := id.ClanToChat() + s.client.Write(NewClientMsg(&MsgClientJoinChat{ + SteamIdChat: chatId, + }, make([]byte, 0))) +} + +// Attempts to leave a chat room +func (s *Social) LeaveChat(id SteamId) { + chatId := id.ClanToChat() + payload := new(bytes.Buffer) + binary.Write(payload, binary.LittleEndian, s.client.SteamId().ToUint64()) // ChatterActedOn + binary.Write(payload, binary.LittleEndian, uint32(EChatMemberStateChange_Left)) // StateChange + binary.Write(payload, binary.LittleEndian, s.client.SteamId().ToUint64()) // ChatterActedBy + s.client.Write(NewClientMsg(&MsgClientChatMemberInfo{ + SteamIdChat: chatId, + Type: EChatInfoType_StateChange, + }, payload.Bytes())) +} + +// Kicks the specified chat member from the given chat room +func (s *Social) KickChatMember(room SteamId, user SteamId) { + chatId := room.ClanToChat() + s.client.Write(NewClientMsg(&MsgClientChatAction{ + SteamIdChat: chatId, + SteamIdUserToActOn: user, + ChatAction: EChatAction_Kick, + }, make([]byte, 0))) +} + +// Bans the specified chat member from the given chat room +func (s *Social) BanChatMember(room SteamId, user SteamId) { + chatId := room.ClanToChat() + s.client.Write(NewClientMsg(&MsgClientChatAction{ + SteamIdChat: chatId, + SteamIdUserToActOn: user, + ChatAction: EChatAction_Ban, + }, make([]byte, 0))) +} + +// Unbans the specified chat member from the given chat room +func (s *Social) UnbanChatMember(room SteamId, user SteamId) { + chatId := room.ClanToChat() + s.client.Write(NewClientMsg(&MsgClientChatAction{ + SteamIdChat: chatId, + SteamIdUserToActOn: user, + ChatAction: EChatAction_UnBan, + }, make([]byte, 0))) +} + +func (s *Social) HandlePacket(packet *Packet) { + switch packet.EMsg { + case EMsg_ClientPersonaState: + s.handlePersonaState(packet) + case EMsg_ClientClanState: + s.handleClanState(packet) + case EMsg_ClientFriendsList: + s.handleFriendsList(packet) + case EMsg_ClientFriendMsgIncoming: + s.handleFriendMsg(packet) + case EMsg_ClientAccountInfo: + s.handleAccountInfo(packet) + case EMsg_ClientAddFriendResponse: + s.handleFriendResponse(packet) + case EMsg_ClientChatEnter: + s.handleChatEnter(packet) + case EMsg_ClientChatMsg: + s.handleChatMsg(packet) + case EMsg_ClientChatMemberInfo: + s.handleChatMemberInfo(packet) + case EMsg_ClientChatActionResult: + s.handleChatActionResult(packet) + case EMsg_ClientChatInvite: + s.handleChatInvite(packet) + case EMsg_ClientSetIgnoreFriendResponse: + s.handleIgnoreFriendResponse(packet) + case EMsg_ClientFriendProfileInfoResponse: + s.handleProfileInfoResponse(packet) + case EMsg_ClientFSGetFriendMessageHistoryResponse: + s.handleFriendMessageHistoryResponse(packet) + } +} + +func (s *Social) handleAccountInfo(packet *Packet) { + //Just fire the personainfo, Auth handles the callback + flags := EClientPersonaStateFlag_PlayerName | EClientPersonaStateFlag_Presence | EClientPersonaStateFlag_SourceID + s.RequestFriendInfo(s.client.SteamId(), EClientPersonaStateFlag(flags)) +} + +func (s *Social) handleFriendsList(packet *Packet) { + list := new(CMsgClientFriendsList) + packet.ReadProtoMsg(list) + var friends []SteamId + for _, friend := range list.GetFriends() { + steamId := SteamId(friend.GetUlfriendid()) + isClan := steamId.GetAccountType() == int32(EAccountType_Clan) + + if isClan { + rel := EClanRelationship(friend.GetEfriendrelationship()) + if rel == EClanRelationship_None { + s.Groups.Remove(steamId) + } else { + s.Groups.Add(socialcache.Group{ + SteamId: steamId, + Relationship: rel, + }) + + } + if list.GetBincremental() { + s.client.Emit(&GroupStateEvent{steamId, rel}) + } + } else { + rel := EFriendRelationship(friend.GetEfriendrelationship()) + if rel == EFriendRelationship_None { + s.Friends.Remove(steamId) + } else { + s.Friends.Add(socialcache.Friend{ + SteamId: steamId, + Relationship: rel, + }) + + } + if list.GetBincremental() { + s.client.Emit(&FriendStateEvent{steamId, rel}) + } + } + if !list.GetBincremental() { + friends = append(friends, steamId) + } + } + if !list.GetBincremental() { + s.RequestFriendListInfo(friends, EClientPersonaStateFlag_DefaultInfoRequest) + s.client.Emit(&FriendsListEvent{}) + } +} + +func (s *Social) handlePersonaState(packet *Packet) { + list := new(CMsgClientPersonaState) + packet.ReadProtoMsg(list) + flags := EClientPersonaStateFlag(list.GetStatusFlags()) + for _, friend := range list.GetFriends() { + id := SteamId(friend.GetFriendid()) + if id == s.client.SteamId() { //this is our client id + s.mutex.Lock() + if friend.GetPlayerName() != "" { + s.name = friend.GetPlayerName() + } + avatar := hex.EncodeToString(friend.GetAvatarHash()) + if ValidAvatar(avatar) { + s.avatar = avatar + } + s.mutex.Unlock() + } else if id.GetAccountType() == int32(EAccountType_Individual) { + if (flags & EClientPersonaStateFlag_PlayerName) == EClientPersonaStateFlag_PlayerName { + if friend.GetPlayerName() != "" { + s.Friends.SetName(id, friend.GetPlayerName()) + } + } + if (flags & EClientPersonaStateFlag_Presence) == EClientPersonaStateFlag_Presence { + avatar := hex.EncodeToString(friend.GetAvatarHash()) + if ValidAvatar(avatar) { + s.Friends.SetAvatar(id, avatar) + } + s.Friends.SetPersonaState(id, EPersonaState(friend.GetPersonaState())) + s.Friends.SetPersonaStateFlags(id, EPersonaStateFlag(friend.GetPersonaStateFlags())) + } + if (flags & EClientPersonaStateFlag_GameDataBlob) == EClientPersonaStateFlag_GameDataBlob { + s.Friends.SetGameAppId(id, friend.GetGamePlayedAppId()) + s.Friends.SetGameId(id, friend.GetGameid()) + s.Friends.SetGameName(id, friend.GetGameName()) + } + } else if id.GetAccountType() == int32(EAccountType_Clan) { + if (flags & EClientPersonaStateFlag_PlayerName) == EClientPersonaStateFlag_PlayerName { + if friend.GetPlayerName() != "" { + s.Groups.SetName(id, friend.GetPlayerName()) + } + } + if (flags & EClientPersonaStateFlag_Presence) == EClientPersonaStateFlag_Presence { + avatar := hex.EncodeToString(friend.GetAvatarHash()) + if ValidAvatar(avatar) { + s.Groups.SetAvatar(id, avatar) + } + } + } + s.client.Emit(&PersonaStateEvent{ + StatusFlags: flags, + FriendId: id, + State: EPersonaState(friend.GetPersonaState()), + StateFlags: EPersonaStateFlag(friend.GetPersonaStateFlags()), + GameAppId: friend.GetGamePlayedAppId(), + GameId: friend.GetGameid(), + GameName: friend.GetGameName(), + GameServerIp: friend.GetGameServerIp(), + GameServerPort: friend.GetGameServerPort(), + QueryPort: friend.GetQueryPort(), + SourceSteamId: SteamId(friend.GetSteamidSource()), + GameDataBlob: friend.GetGameDataBlob(), + Name: friend.GetPlayerName(), + Avatar: hex.EncodeToString(friend.GetAvatarHash()), + LastLogOff: friend.GetLastLogoff(), + LastLogOn: friend.GetLastLogon(), + ClanRank: friend.GetClanRank(), + ClanTag: friend.GetClanTag(), + OnlineSessionInstances: friend.GetOnlineSessionInstances(), + PublishedSessionId: friend.GetPublishedInstanceId(), + PersonaSetByUser: friend.GetPersonaSetByUser(), + FacebookName: friend.GetFacebookName(), + FacebookId: friend.GetFacebookId(), + }) + } +} + +func (s *Social) handleClanState(packet *Packet) { + body := new(CMsgClientClanState) + packet.ReadProtoMsg(body) + var name string + var avatar string + if body.GetNameInfo() != nil { + name = body.GetNameInfo().GetClanName() + avatar = hex.EncodeToString(body.GetNameInfo().GetShaAvatar()) + } + var totalCount, onlineCount, chattingCount, ingameCount uint32 + if body.GetUserCounts() != nil { + usercounts := body.GetUserCounts() + totalCount = usercounts.GetMembers() + onlineCount = usercounts.GetOnline() + chattingCount = usercounts.GetChatting() + ingameCount = usercounts.GetInGame() + } + var events, announcements []ClanEventDetails + for _, event := range body.GetEvents() { + events = append(events, ClanEventDetails{ + Id: event.GetGid(), + EventTime: event.GetEventTime(), + Headline: event.GetHeadline(), + GameId: event.GetGameId(), + JustPosted: event.GetJustPosted(), + }) + } + for _, announce := range body.GetAnnouncements() { + announcements = append(announcements, ClanEventDetails{ + Id: announce.GetGid(), + EventTime: announce.GetEventTime(), + Headline: announce.GetHeadline(), + GameId: announce.GetGameId(), + JustPosted: announce.GetJustPosted(), + }) + } + flags := EClientPersonaStateFlag(body.GetMUnStatusFlags()) + //Add stuff to group + clanid := SteamId(body.GetSteamidClan()) + if (flags & EClientPersonaStateFlag_PlayerName) == EClientPersonaStateFlag_PlayerName { + if name != "" { + s.Groups.SetName(clanid, name) + } + } + if (flags & EClientPersonaStateFlag_Presence) == EClientPersonaStateFlag_Presence { + if ValidAvatar(avatar) { + s.Groups.SetAvatar(clanid, avatar) + } + } + if body.GetUserCounts() != nil { + s.Groups.SetMemberTotalCount(clanid, totalCount) + s.Groups.SetMemberOnlineCount(clanid, onlineCount) + s.Groups.SetMemberChattingCount(clanid, chattingCount) + s.Groups.SetMemberInGameCount(clanid, ingameCount) + } + s.client.Emit(&ClanStateEvent{ + ClandId: clanid, + StateFlags: EClientPersonaStateFlag(body.GetMUnStatusFlags()), + AccountFlags: EAccountFlags(body.GetClanAccountFlags()), + ClanName: name, + Avatar: avatar, + MemberTotalCount: totalCount, + MemberOnlineCount: onlineCount, + MemberChattingCount: chattingCount, + MemberInGameCount: ingameCount, + Events: events, + Announcements: announcements, + }) +} + +func (s *Social) handleFriendResponse(packet *Packet) { + body := new(CMsgClientAddFriendResponse) + packet.ReadProtoMsg(body) + s.client.Emit(&FriendAddedEvent{ + Result: EResult(body.GetEresult()), + SteamId: SteamId(body.GetSteamIdAdded()), + PersonaName: body.GetPersonaNameAdded(), + }) +} + +func (s *Social) handleFriendMsg(packet *Packet) { + body := new(CMsgClientFriendMsgIncoming) + packet.ReadProtoMsg(body) + message := string(bytes.Split(body.GetMessage(), []byte{0x0})[0]) + s.client.Emit(&ChatMsgEvent{ + ChatterId: SteamId(body.GetSteamidFrom()), + Message: message, + EntryType: EChatEntryType(body.GetChatEntryType()), + Timestamp: time.Unix(int64(body.GetRtime32ServerTimestamp()), 0), + }) +} + +func (s *Social) handleChatMsg(packet *Packet) { + body := new(MsgClientChatMsg) + payload := packet.ReadClientMsg(body).Payload + message := string(bytes.Split(payload, []byte{0x0})[0]) + s.client.Emit(&ChatMsgEvent{ + ChatRoomId: SteamId(body.SteamIdChatRoom), + ChatterId: SteamId(body.SteamIdChatter), + Message: message, + EntryType: EChatEntryType(body.ChatMsgType), + }) +} + +func (s *Social) handleChatEnter(packet *Packet) { + body := new(MsgClientChatEnter) + payload := packet.ReadClientMsg(body).Payload + reader := bytes.NewBuffer(payload) + name, _ := ReadString(reader) + ReadByte(reader) //0 + count := body.NumMembers + chatId := SteamId(body.SteamIdChat) + clanId := SteamId(body.SteamIdClan) + s.Chats.Add(socialcache.Chat{SteamId: chatId, GroupId: clanId}) + for i := 0; i < int(count); i++ { + id, chatPerm, clanPerm := readChatMember(reader) + ReadBytes(reader, 6) //No idea what this is + s.Chats.AddChatMember(chatId, socialcache.ChatMember{ + SteamId: SteamId(id), + ChatPermissions: chatPerm, + ClanPermissions: clanPerm, + }) + } + s.client.Emit(&ChatEnterEvent{ + ChatRoomId: SteamId(body.SteamIdChat), + FriendId: SteamId(body.SteamIdFriend), + ChatRoomType: EChatRoomType(body.ChatRoomType), + OwnerId: SteamId(body.SteamIdOwner), + ClanId: SteamId(body.SteamIdClan), + ChatFlags: byte(body.ChatFlags), + EnterResponse: EChatRoomEnterResponse(body.EnterResponse), + Name: name, + }) +} + +func (s *Social) handleChatMemberInfo(packet *Packet) { + body := new(MsgClientChatMemberInfo) + payload := packet.ReadClientMsg(body).Payload + reader := bytes.NewBuffer(payload) + chatId := SteamId(body.SteamIdChat) + if body.Type == EChatInfoType_StateChange { + actedOn, _ := ReadUint64(reader) + state, _ := ReadInt32(reader) + actedBy, _ := ReadUint64(reader) + ReadByte(reader) //0 + stateChange := EChatMemberStateChange(state) + if stateChange == EChatMemberStateChange_Entered { + _, chatPerm, clanPerm := readChatMember(reader) + s.Chats.AddChatMember(chatId, socialcache.ChatMember{ + SteamId: SteamId(actedOn), + ChatPermissions: chatPerm, + ClanPermissions: clanPerm, + }) + } else if stateChange == EChatMemberStateChange_Banned || stateChange == EChatMemberStateChange_Kicked || + stateChange == EChatMemberStateChange_Disconnected || stateChange == EChatMemberStateChange_Left { + s.Chats.RemoveChatMember(chatId, SteamId(actedOn)) + } + stateInfo := StateChangeDetails{ + ChatterActedOn: SteamId(actedOn), + StateChange: EChatMemberStateChange(stateChange), + ChatterActedBy: SteamId(actedBy), + } + s.client.Emit(&ChatMemberInfoEvent{ + ChatRoomId: SteamId(body.SteamIdChat), + Type: EChatInfoType(body.Type), + StateChangeInfo: stateInfo, + }) + } +} + +func readChatMember(r io.Reader) (SteamId, EChatPermission, EClanPermission) { + ReadString(r) // MessageObject + ReadByte(r) // 7 + ReadString(r) //steamid + id, _ := ReadUint64(r) + ReadByte(r) // 2 + ReadString(r) //Permissions + chat, _ := ReadInt32(r) + ReadByte(r) // 2 + ReadString(r) //Details + clan, _ := ReadInt32(r) + return SteamId(id), EChatPermission(chat), EClanPermission(clan) +} + +func (s *Social) handleChatActionResult(packet *Packet) { + body := new(MsgClientChatActionResult) + packet.ReadClientMsg(body) + s.client.Emit(&ChatActionResultEvent{ + ChatRoomId: SteamId(body.SteamIdChat), + ChatterId: SteamId(body.SteamIdUserActedOn), + Action: EChatAction(body.ChatAction), + Result: EChatActionResult(body.ActionResult), + }) +} + +func (s *Social) handleChatInvite(packet *Packet) { + body := new(CMsgClientChatInvite) + packet.ReadProtoMsg(body) + s.client.Emit(&ChatInviteEvent{ + InvitedId: SteamId(body.GetSteamIdInvited()), + ChatRoomId: SteamId(body.GetSteamIdChat()), + PatronId: SteamId(body.GetSteamIdPatron()), + ChatRoomType: EChatRoomType(body.GetChatroomType()), + FriendChatId: SteamId(body.GetSteamIdFriendChat()), + ChatRoomName: body.GetChatName(), + GameId: body.GetGameId(), + }) +} + +func (s *Social) handleIgnoreFriendResponse(packet *Packet) { + body := new(MsgClientSetIgnoreFriendResponse) + packet.ReadClientMsg(body) + s.client.Emit(&IgnoreFriendEvent{ + Result: EResult(body.Result), + }) +} + +func (s *Social) handleProfileInfoResponse(packet *Packet) { + body := new(CMsgClientFriendProfileInfoResponse) + packet.ReadProtoMsg(body) + s.client.Emit(&ProfileInfoEvent{ + Result: EResult(body.GetEresult()), + SteamId: SteamId(body.GetSteamidFriend()), + TimeCreated: body.GetTimeCreated(), + RealName: body.GetRealName(), + CityName: body.GetCityName(), + StateName: body.GetStateName(), + CountryName: body.GetCountryName(), + Headline: body.GetHeadline(), + Summary: body.GetSummary(), + }) +} + +func (s *Social) handleFriendMessageHistoryResponse(packet *Packet) { + body := new(CMsgClientFSGetFriendMessageHistoryResponse) + packet.ReadProtoMsg(body) + steamid := SteamId(body.GetSteamid()) + for _, message := range body.GetMessages() { + if !message.GetUnread() { + continue // Skip already read messages + } + s.client.Emit(&ChatMsgEvent{ + ChatterId: steamid, + Message: message.GetMessage(), + EntryType: EChatEntryType_ChatMsg, + Timestamp: time.Unix(int64(message.GetTimestamp()), 0), + Offline: true, // GetUnread is true + }) + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/social_events.go b/vendor/github.com/Philipp15b/go-steam/social_events.go new file mode 100644 index 00000000..f17a650a --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/social_events.go @@ -0,0 +1,161 @@ +package steam + +import ( + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" + "time" +) + +type FriendsListEvent struct{} + +type FriendStateEvent struct { + SteamId SteamId `json:",string"` + Relationship EFriendRelationship +} + +func (f *FriendStateEvent) IsFriend() bool { + return f.Relationship == EFriendRelationship_Friend +} + +type GroupStateEvent struct { + SteamId SteamId `json:",string"` + Relationship EClanRelationship +} + +func (g *GroupStateEvent) IsMember() bool { + return g.Relationship == EClanRelationship_Member +} + +// Fired when someone changing their friend details +type PersonaStateEvent struct { + StatusFlags EClientPersonaStateFlag + FriendId SteamId `json:",string"` + State EPersonaState + StateFlags EPersonaStateFlag + GameAppId uint32 + GameId uint64 `json:",string"` + GameName string + GameServerIp uint32 + GameServerPort uint32 + QueryPort uint32 + SourceSteamId SteamId `json:",string"` + GameDataBlob []byte + Name string + Avatar string + LastLogOff uint32 + LastLogOn uint32 + ClanRank uint32 + ClanTag string + OnlineSessionInstances uint32 + PublishedSessionId uint32 + PersonaSetByUser bool + FacebookName string + FacebookId uint64 `json:",string"` +} + +// Fired when a clan's state has been changed +type ClanStateEvent struct { + ClandId SteamId `json:",string"` + StateFlags EClientPersonaStateFlag + AccountFlags EAccountFlags + ClanName string + Avatar string + MemberTotalCount uint32 + MemberOnlineCount uint32 + MemberChattingCount uint32 + MemberInGameCount uint32 + Events []ClanEventDetails + Announcements []ClanEventDetails +} + +type ClanEventDetails struct { + Id uint64 `json:",string"` + EventTime uint32 + Headline string + GameId uint64 `json:",string"` + JustPosted bool +} + +// Fired in response to adding a friend to your friends list +type FriendAddedEvent struct { + Result EResult + SteamId SteamId `json:",string"` + PersonaName string +} + +// Fired when the client receives a message from either a friend or a chat room +type ChatMsgEvent struct { + ChatRoomId SteamId `json:",string"` // not set for friend messages + ChatterId SteamId `json:",string"` + Message string + EntryType EChatEntryType + Timestamp time.Time + Offline bool +} + +// Whether the type is ChatMsg +func (c *ChatMsgEvent) IsMessage() bool { + return c.EntryType == EChatEntryType_ChatMsg +} + +// Fired in response to joining a chat +type ChatEnterEvent struct { + ChatRoomId SteamId `json:",string"` + FriendId SteamId `json:",string"` + ChatRoomType EChatRoomType + OwnerId SteamId `json:",string"` + ClanId SteamId `json:",string"` + ChatFlags byte + EnterResponse EChatRoomEnterResponse + Name string +} + +// Fired in response to a chat member's info being received +type ChatMemberInfoEvent struct { + ChatRoomId SteamId `json:",string"` + Type EChatInfoType + StateChangeInfo StateChangeDetails +} + +type StateChangeDetails struct { + ChatterActedOn SteamId `json:",string"` + StateChange EChatMemberStateChange + ChatterActedBy SteamId `json:",string"` +} + +// Fired when a chat action has completed +type ChatActionResultEvent struct { + ChatRoomId SteamId `json:",string"` + ChatterId SteamId `json:",string"` + Action EChatAction + Result EChatActionResult +} + +// Fired when a chat invite is received +type ChatInviteEvent struct { + InvitedId SteamId `json:",string"` + ChatRoomId SteamId `json:",string"` + PatronId SteamId `json:",string"` + ChatRoomType EChatRoomType + FriendChatId SteamId `json:",string"` + ChatRoomName string + GameId uint64 `json:",string"` +} + +// Fired in response to ignoring a friend +type IgnoreFriendEvent struct { + Result EResult +} + +// Fired in response to requesting profile info for a user +type ProfileInfoEvent struct { + Result EResult + SteamId SteamId `json:",string"` + TimeCreated uint32 + RealName string + CityName string + StateName string + CountryName string + Headline string + Summary string +} diff --git a/vendor/github.com/Philipp15b/go-steam/socialcache/chats.go b/vendor/github.com/Philipp15b/go-steam/socialcache/chats.go new file mode 100644 index 00000000..5eec6ad1 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/socialcache/chats.go @@ -0,0 +1,111 @@ +package socialcache + +import ( + "errors" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" + "sync" +) + +// Chats list is a thread safe map +// They can be iterated over like so: +// for id, chat := range client.Social.Chats.GetCopy() { +// log.Println(id, chat.Name) +// } +type ChatsList struct { + mutex sync.RWMutex + byId map[SteamId]*Chat +} + +// Returns a new chats list +func NewChatsList() *ChatsList { + return &ChatsList{byId: make(map[SteamId]*Chat)} +} + +// Adds a chat to the chat list +func (list *ChatsList) Add(chat Chat) { + list.mutex.Lock() + defer list.mutex.Unlock() + _, exists := list.byId[chat.SteamId] + if !exists { //make sure this doesnt already exist + list.byId[chat.SteamId] = &chat + } +} + +// Removes a chat from the chat list +func (list *ChatsList) Remove(id SteamId) { + list.mutex.Lock() + defer list.mutex.Unlock() + delete(list.byId, id) +} + +// Adds a chat member to a given chat +func (list *ChatsList) AddChatMember(id SteamId, member ChatMember) { + list.mutex.Lock() + defer list.mutex.Unlock() + chat := list.byId[id] + if chat == nil { //Chat doesn't exist + chat = &Chat{SteamId: id} + list.byId[id] = chat + } + if chat.ChatMembers == nil { //New chat + chat.ChatMembers = make(map[SteamId]ChatMember) + } + chat.ChatMembers[member.SteamId] = member +} + +// Removes a chat member from a given chat +func (list *ChatsList) RemoveChatMember(id SteamId, member SteamId) { + list.mutex.Lock() + defer list.mutex.Unlock() + chat := list.byId[id] + if chat == nil { //Chat doesn't exist + return + } + if chat.ChatMembers == nil { //New chat + return + } + delete(chat.ChatMembers, member) +} + +// Returns a copy of the chats map +func (list *ChatsList) GetCopy() map[SteamId]Chat { + list.mutex.RLock() + defer list.mutex.RUnlock() + glist := make(map[SteamId]Chat) + for key, chat := range list.byId { + glist[key] = *chat + } + return glist +} + +// Returns a copy of the chat of a given SteamId +func (list *ChatsList) ById(id SteamId) (Chat, error) { + list.mutex.RLock() + defer list.mutex.RUnlock() + if val, ok := list.byId[id]; ok { + return *val, nil + } + return Chat{}, errors.New("Chat not found") +} + +// Returns the number of chats +func (list *ChatsList) Count() int { + list.mutex.RLock() + defer list.mutex.RUnlock() + return len(list.byId) +} + +// A Chat +type Chat struct { + SteamId SteamId `json:",string"` + GroupId SteamId `json:",string"` + ChatMembers map[SteamId]ChatMember +} + +// A Chat Member +type ChatMember struct { + SteamId SteamId `json:",string"` + ChatPermissions EChatPermission + ClanPermissions EClanPermission +} diff --git a/vendor/github.com/Philipp15b/go-steam/socialcache/friends.go b/vendor/github.com/Philipp15b/go-steam/socialcache/friends.go new file mode 100644 index 00000000..15168b80 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/socialcache/friends.go @@ -0,0 +1,146 @@ +package socialcache + +import ( + "errors" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" + "sync" +) + +// Friends list is a thread safe map +// They can be iterated over like so: +// for id, friend := range client.Social.Friends.GetCopy() { +// log.Println(id, friend.Name) +// } +type FriendsList struct { + mutex sync.RWMutex + byId map[SteamId]*Friend +} + +// Returns a new friends list +func NewFriendsList() *FriendsList { + return &FriendsList{byId: make(map[SteamId]*Friend)} +} + +// Adds a friend to the friend list +func (list *FriendsList) Add(friend Friend) { + list.mutex.Lock() + defer list.mutex.Unlock() + _, exists := list.byId[friend.SteamId] + if !exists { //make sure this doesnt already exist + list.byId[friend.SteamId] = &friend + } +} + +// Removes a friend from the friend list +func (list *FriendsList) Remove(id SteamId) { + list.mutex.Lock() + defer list.mutex.Unlock() + delete(list.byId, id) +} + +// Returns a copy of the friends map +func (list *FriendsList) GetCopy() map[SteamId]Friend { + list.mutex.RLock() + defer list.mutex.RUnlock() + flist := make(map[SteamId]Friend) + for key, friend := range list.byId { + flist[key] = *friend + } + return flist +} + +// Returns a copy of the friend of a given SteamId +func (list *FriendsList) ById(id SteamId) (Friend, error) { + list.mutex.RLock() + defer list.mutex.RUnlock() + if val, ok := list.byId[id]; ok { + return *val, nil + } + return Friend{}, errors.New("Friend not found") +} + +// Returns the number of friends +func (list *FriendsList) Count() int { + list.mutex.RLock() + defer list.mutex.RUnlock() + return len(list.byId) +} + +//Setter methods +func (list *FriendsList) SetName(id SteamId, name string) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.Name = name + } +} + +func (list *FriendsList) SetAvatar(id SteamId, hash string) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.Avatar = hash + } +} + +func (list *FriendsList) SetRelationship(id SteamId, relationship EFriendRelationship) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.Relationship = relationship + } +} + +func (list *FriendsList) SetPersonaState(id SteamId, state EPersonaState) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.PersonaState = state + } +} + +func (list *FriendsList) SetPersonaStateFlags(id SteamId, flags EPersonaStateFlag) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.PersonaStateFlags = flags + } +} + +func (list *FriendsList) SetGameAppId(id SteamId, gameappid uint32) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.GameAppId = gameappid + } +} + +func (list *FriendsList) SetGameId(id SteamId, gameid uint64) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.GameId = gameid + } +} + +func (list *FriendsList) SetGameName(id SteamId, name string) { + list.mutex.Lock() + defer list.mutex.Unlock() + if val, ok := list.byId[id]; ok { + val.GameName = name + } +} + +// A Friend +type Friend struct { + SteamId SteamId `json:",string"` + Name string + Avatar string + Relationship EFriendRelationship + PersonaState EPersonaState + PersonaStateFlags EPersonaStateFlag + GameAppId uint32 + GameId uint64 `json:",string"` + GameName string +} diff --git a/vendor/github.com/Philipp15b/go-steam/socialcache/groups.go b/vendor/github.com/Philipp15b/go-steam/socialcache/groups.go new file mode 100644 index 00000000..6acce20f --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/socialcache/groups.go @@ -0,0 +1,145 @@ +package socialcache + +import ( + "errors" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" + "sync" +) + +// Groups list is a thread safe map +// They can be iterated over like so: +// for id, group := range client.Social.Groups.GetCopy() { +// log.Println(id, group.Name) +// } +type GroupsList struct { + mutex sync.RWMutex + byId map[SteamId]*Group +} + +// Returns a new groups list +func NewGroupsList() *GroupsList { + return &GroupsList{byId: make(map[SteamId]*Group)} +} + +// Adds a group to the group list +func (list *GroupsList) Add(group Group) { + list.mutex.Lock() + defer list.mutex.Unlock() + _, exists := list.byId[group.SteamId] + if !exists { //make sure this doesnt already exist + list.byId[group.SteamId] = &group + } +} + +// Removes a group from the group list +func (list *GroupsList) Remove(id SteamId) { + list.mutex.Lock() + defer list.mutex.Unlock() + delete(list.byId, id) +} + +// Returns a copy of the groups map +func (list *GroupsList) GetCopy() map[SteamId]Group { + list.mutex.RLock() + defer list.mutex.RUnlock() + glist := make(map[SteamId]Group) + for key, group := range list.byId { + glist[key] = *group + } + return glist +} + +// Returns a copy of the group of a given SteamId +func (list *GroupsList) ById(id SteamId) (Group, error) { + list.mutex.RLock() + defer list.mutex.RUnlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + return *val, nil + } + return Group{}, errors.New("Group not found") +} + +// Returns the number of groups +func (list *GroupsList) Count() int { + list.mutex.RLock() + defer list.mutex.RUnlock() + return len(list.byId) +} + +//Setter methods +func (list *GroupsList) SetName(id SteamId, name string) { + list.mutex.Lock() + defer list.mutex.Unlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + val.Name = name + } +} + +func (list *GroupsList) SetAvatar(id SteamId, hash string) { + list.mutex.Lock() + defer list.mutex.Unlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + val.Avatar = hash + } +} + +func (list *GroupsList) SetRelationship(id SteamId, relationship EClanRelationship) { + list.mutex.Lock() + defer list.mutex.Unlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + val.Relationship = relationship + } +} + +func (list *GroupsList) SetMemberTotalCount(id SteamId, count uint32) { + list.mutex.Lock() + defer list.mutex.Unlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + val.MemberTotalCount = count + } +} + +func (list *GroupsList) SetMemberOnlineCount(id SteamId, count uint32) { + list.mutex.Lock() + defer list.mutex.Unlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + val.MemberOnlineCount = count + } +} + +func (list *GroupsList) SetMemberChattingCount(id SteamId, count uint32) { + list.mutex.Lock() + defer list.mutex.Unlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + val.MemberChattingCount = count + } +} + +func (list *GroupsList) SetMemberInGameCount(id SteamId, count uint32) { + list.mutex.Lock() + defer list.mutex.Unlock() + id = id.ChatToClan() + if val, ok := list.byId[id]; ok { + val.MemberInGameCount = count + } +} + +// A Group +type Group struct { + SteamId SteamId `json:",string"` + Name string + Avatar string + Relationship EClanRelationship + MemberTotalCount uint32 + MemberOnlineCount uint32 + MemberChattingCount uint32 + MemberInGameCount uint32 +} diff --git a/vendor/github.com/Philipp15b/go-steam/steam_directory.go b/vendor/github.com/Philipp15b/go-steam/steam_directory.go new file mode 100644 index 00000000..80d919f0 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/steam_directory.go @@ -0,0 +1,76 @@ +package steam + +import ( + "encoding/json" + "fmt" + "math/rand" + "net/http" + "sync" + "time" + + "github.com/Philipp15b/go-steam/netutil" +) + +// Load initial server list from Steam Directory Web API. +// Call InitializeSteamDirectory() before Connect() to use +// steam directory server list instead of static one. +func InitializeSteamDirectory() error { + return steamDirectoryCache.Initialize() +} + +var steamDirectoryCache *steamDirectory = &steamDirectory{} + +type steamDirectory struct { + sync.RWMutex + servers []string + isInitialized bool +} + +// Get server list from steam directory and save it for later +func (sd *steamDirectory) Initialize() error { + sd.Lock() + defer sd.Unlock() + client := new(http.Client) + resp, err := client.Get(fmt.Sprintf("https://api.steampowered.com/ISteamDirectory/GetCMList/v1/?cellId=0")) + if err != nil { + return err + } + defer resp.Body.Close() + r := struct { + Response struct { + ServerList []string + Result uint32 + Message string + } + }{} + if err = json.NewDecoder(resp.Body).Decode(&r); err != nil { + return err + } + if r.Response.Result != 1 { + return fmt.Errorf("Failed to get steam directory, result: %v, message: %v\n", r.Response.Result, r.Response.Message) + } + if len(r.Response.ServerList) == 0 { + return fmt.Errorf("Steam returned zero servers for steam directory request\n") + } + sd.servers = r.Response.ServerList + sd.isInitialized = true + return nil +} + +func (sd *steamDirectory) GetRandomCM() *netutil.PortAddr { + sd.RLock() + defer sd.RUnlock() + if !sd.isInitialized { + panic("steam directory is not initialized") + } + rng := rand.New(rand.NewSource(time.Now().UnixNano())) + addr := netutil.ParsePortAddr(sd.servers[rng.Int31n(int32(len(sd.servers)))]) + return addr +} + +func (sd *steamDirectory) IsInitialized() bool { + sd.RLock() + defer sd.RUnlock() + isInitialized := sd.isInitialized + return isInitialized +} diff --git a/vendor/github.com/Philipp15b/go-steam/steamid/steamid.go b/vendor/github.com/Philipp15b/go-steam/steamid/steamid.go new file mode 100644 index 00000000..922bb244 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/steamid/steamid.go @@ -0,0 +1,136 @@ +package steamid + +import ( + "fmt" + "strconv" + "errors" + "regexp" + "strings" +) + +type ChatInstanceFlag uint64 + +const ( + Clan ChatInstanceFlag = 0x100000 >> 1 + Lobby ChatInstanceFlag = 0x100000 >> 2 + MMSLobby ChatInstanceFlag = 0x100000 >> 3 +) + +type SteamId uint64 + +func NewId(id string) (SteamId, error) { + valid, err := regexp.MatchString(`STEAM_[0-5]:[01]:\d+`, id) + if err != nil { + return SteamId(0), err + } + if valid { + id = strings.Replace(id, "STEAM_", "", -1) // remove STEAM_ + splitid := strings.Split(id, ":") // split 0:1:00000000 into 0 1 00000000 + universe, _ := strconv.ParseInt(splitid[0], 10, 32) + if universe == 0 { //EUniverse_Invalid + universe = 1 //EUniverse_Public + } + authServer, _ := strconv.ParseUint(splitid[1], 10, 32) + accId, _ := strconv.ParseUint(splitid[2], 10, 32) + accountType := int32(1) //EAccountType_Individual + accountId := (uint32(accId) << 1) | uint32(authServer) + return NewIdAdv(uint32(accountId), 1, int32(universe), accountType), nil + } else { + newid, err := strconv.ParseUint(id, 10, 64) + if err != nil { + return SteamId(0), err + } + return SteamId(newid), nil + } + return SteamId(0), errors.New(fmt.Sprintf("Invalid SteamId: %s\n", id)) +} + +func NewIdAdv(accountId, instance uint32, universe int32, accountType int32) SteamId { + s := SteamId(0) + s = s.SetAccountId(accountId) + s = s.SetAccountInstance(instance) + s = s.SetAccountUniverse(universe) + s = s.SetAccountType(accountType) + return s +} + +func (s SteamId) ToUint64() uint64 { + return uint64(s) +} + +func (s SteamId) ToString() string { + return strconv.FormatUint(uint64(s), 10) +} + +func (s SteamId) String() string { + switch s.GetAccountType() { + case 0: // EAccountType_Invalid + fallthrough + case 1: // EAccountType_Individual + if s.GetAccountUniverse() <= 1 { // EUniverse_Public + return fmt.Sprintf("STEAM_0:%d:%d", s.GetAccountId()&1, s.GetAccountId()>>1) + } else { + return fmt.Sprintf("STEAM_%d:%d:%d", s.GetAccountUniverse(), s.GetAccountId()&1, s.GetAccountId()>>1) + } + default: + return strconv.FormatUint(uint64(s), 10) + } +} + +func (s SteamId) get(offset uint, mask uint64) uint64 { + return (uint64(s) >> offset) & mask +} + +func (s SteamId) set(offset uint, mask, value uint64) SteamId { + return SteamId((uint64(s) & ^(mask << offset)) | (value&mask)< event +func (e *EventList) UnmarshalJSON(data []byte) error { + // initialize the map if it's nil + if *e == nil { + *e = make(EventList) + } + + o := make(map[string]*Event) + err := json.Unmarshal(data, &o) + // it's an object + if err == nil { + for is, event := range o { + i, err := strconv.ParseUint(is, 10, 32) + if err != nil { + panic(err) + } + (*e)[uint(i)] = event + } + return nil + } + + // it's an array + var a []*Event + err = json.Unmarshal(data, &a) + if err != nil { + return err + } + for i, event := range a { + (*e)[uint(i)] = event + } + return nil +} + +type Event struct { + SteamId steamid.SteamId `json:",string"` + Action Action `json:",string"` + Timestamp uint64 + + AppId uint32 + ContextId uint64 `json:",string"` + AssetId uint64 `json:",string"` + + Text string // only used for chat messages + + // The following is used for SetCurrency + CurrencyId uint64 `json:",string"` + OldAmount uint64 `json:"old_amount,string"` + NewAmount uint64 `json:"amount,string"` +} + +type Action uint + +const ( + Action_AddItem Action = 0 + Action_RemoveItem = 1 + Action_Ready = 2 + Action_Unready = 3 + Action_Accept = 4 + Action_SetCurrency = 6 + Action_ChatMessage = 7 +) + +type User struct { + Ready jsont.UintBool + Confirmed jsont.UintBool + SecSinceTouch int `json:"sec_since_touch"` + ConnectionPending bool `json:"connection_pending"` + Assets interface{} + Currency interface{} // either []*Currency or empty string +} + +type Currency struct { + AppId uint64 `json:",string"` + ContextId uint64 `json:",string"` + CurrencyId uint64 `json:",string"` + Amount uint64 `json:",string"` +} diff --git a/vendor/github.com/Philipp15b/go-steam/trade/tradeapi/trade.go b/vendor/github.com/Philipp15b/go-steam/trade/tradeapi/trade.go new file mode 100644 index 00000000..5e9f2a98 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/trade/tradeapi/trade.go @@ -0,0 +1,200 @@ +/* +Wrapper around the HTTP trading API for type safety 'n' stuff. +*/ +package tradeapi + +import ( + "encoding/json" + "errors" + "fmt" + "github.com/Philipp15b/go-steam/community" + "github.com/Philipp15b/go-steam/economy/inventory" + "github.com/Philipp15b/go-steam/netutil" + "github.com/Philipp15b/go-steam/steamid" + "io/ioutil" + "net/http" + "regexp" + "strconv" + "time" +) + +const tradeUrl = "https://steamcommunity.com/trade/%d/" + +type Trade struct { + client *http.Client + other steamid.SteamId + + LogPos uint // not automatically updated + Version uint // Incremented for each item change by Steam; not automatically updated. + + // the `sessionid` cookie is sent as a parameter/POST data for CSRF protection. + sessionId string + baseUrl string +} + +// Creates a new Trade based on the given cookies `sessionid`, `steamLogin`, `steamLoginSecure` and the trade partner's Steam ID. +func New(sessionId, steamLogin, steamLoginSecure string, other steamid.SteamId) *Trade { + client := new(http.Client) + client.Timeout = 10 * time.Second + + t := &Trade{ + client: client, + other: other, + sessionId: sessionId, + baseUrl: fmt.Sprintf(tradeUrl, other), + Version: 1, + } + community.SetCookies(t.client, sessionId, steamLogin, steamLoginSecure) + return t +} + +type Main struct { + PartnerOnProbation bool +} + +var onProbationRegex = regexp.MustCompile(`var g_bTradePartnerProbation = (\w+);`) + +// Fetches the main HTML page and parses it. Thread-safe. +func (t *Trade) GetMain() (*Main, error) { + resp, err := t.client.Get(t.baseUrl) + if err != nil { + return nil, err + } + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + return nil, err + } + + match := onProbationRegex.FindSubmatch(body) + if len(match) == 0 { + return nil, errors.New("tradeapi.GetMain: Could not find probation info") + } + + return &Main{ + string(match[1]) == "true", + }, nil +} + +// Ajax POSTs to an API endpoint that should return a status +func (t *Trade) postWithStatus(url string, data map[string]string) (*Status, error) { + status := new(Status) + + req := netutil.NewPostForm(url, netutil.ToUrlValues(data)) + // Tales of Madness and Pain, Episode 1: If you forget this, Steam will return an error + // saying "missing required parameter", even though they are all there. IT WAS JUST THE HEADER, ARGH! + req.Header.Add("Referer", t.baseUrl) + + resp, err := t.client.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + err = json.NewDecoder(resp.Body).Decode(status) + if err != nil { + return nil, err + } + return status, nil +} + +func (t *Trade) GetStatus() (*Status, error) { + return t.postWithStatus(t.baseUrl+"tradestatus/", map[string]string{ + "sessionid": t.sessionId, + "logpos": strconv.FormatUint(uint64(t.LogPos), 10), + "version": strconv.FormatUint(uint64(t.Version), 10), + }) +} + +// Thread-safe. +func (t *Trade) GetForeignInventory(contextId uint64, appId uint32, start *uint) (*inventory.PartialInventory, error) { + data := map[string]string{ + "sessionid": t.sessionId, + "steamid": fmt.Sprintf("%d", t.other), + "contextid": strconv.FormatUint(contextId, 10), + "appid": strconv.FormatUint(uint64(appId), 10), + } + if start != nil { + data["start"] = strconv.FormatUint(uint64(*start), 10) + } + + req, err := http.NewRequest("GET", t.baseUrl+"foreigninventory?"+netutil.ToUrlValues(data).Encode(), nil) + if err != nil { + panic(err) + } + req.Header.Add("Referer", t.baseUrl) + + return inventory.DoInventoryRequest(t.client, req) +} + +// Thread-safe. +func (t *Trade) GetOwnInventory(contextId uint64, appId uint32) (*inventory.Inventory, error) { + return inventory.GetOwnInventory(t.client, contextId, appId) +} + +func (t *Trade) Chat(message string) (*Status, error) { + return t.postWithStatus(t.baseUrl+"chat", map[string]string{ + "sessionid": t.sessionId, + "logpos": strconv.FormatUint(uint64(t.LogPos), 10), + "version": strconv.FormatUint(uint64(t.Version), 10), + "message": message, + }) +} + +func (t *Trade) AddItem(slot uint, itemId, contextId uint64, appId uint32) (*Status, error) { + return t.postWithStatus(t.baseUrl+"additem", map[string]string{ + "sessionid": t.sessionId, + "slot": strconv.FormatUint(uint64(slot), 10), + "itemid": strconv.FormatUint(itemId, 10), + "contextid": strconv.FormatUint(contextId, 10), + "appid": strconv.FormatUint(uint64(appId), 10), + }) +} + +func (t *Trade) RemoveItem(slot uint, itemId, contextId uint64, appId uint32) (*Status, error) { + return t.postWithStatus(t.baseUrl+"removeitem", map[string]string{ + "sessionid": t.sessionId, + "slot": strconv.FormatUint(uint64(slot), 10), + "itemid": strconv.FormatUint(itemId, 10), + "contextid": strconv.FormatUint(contextId, 10), + "appid": strconv.FormatUint(uint64(appId), 10), + }) +} + +func (t *Trade) SetCurrency(amount uint, currencyId, contextId uint64, appId uint32) (*Status, error) { + return t.postWithStatus(t.baseUrl+"setcurrency", map[string]string{ + "sessionid": t.sessionId, + "amount": strconv.FormatUint(uint64(amount), 10), + "currencyid": strconv.FormatUint(uint64(currencyId), 10), + "contextid": strconv.FormatUint(contextId, 10), + "appid": strconv.FormatUint(uint64(appId), 10), + }) +} + +func (t *Trade) SetReady(ready bool) (*Status, error) { + return t.postWithStatus(t.baseUrl+"toggleready", map[string]string{ + "sessionid": t.sessionId, + "version": strconv.FormatUint(uint64(t.Version), 10), + "ready": fmt.Sprint(ready), + }) +} + +func (t *Trade) Confirm() (*Status, error) { + return t.postWithStatus(t.baseUrl+"confirm", map[string]string{ + "sessionid": t.sessionId, + "version": strconv.FormatUint(uint64(t.Version), 10), + }) +} + +func (t *Trade) Cancel() (*Status, error) { + return t.postWithStatus(t.baseUrl+"cancel", map[string]string{ + "sessionid": t.sessionId, + }) +} + +func isSuccess(v interface{}) bool { + if m, ok := v.(map[string]interface{}); ok { + return m["success"] == true + } + return false +} diff --git a/vendor/github.com/Philipp15b/go-steam/trade/types.go b/vendor/github.com/Philipp15b/go-steam/trade/types.go new file mode 100644 index 00000000..e6f9a537 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/trade/types.go @@ -0,0 +1,67 @@ +package trade + +import ( + "github.com/Philipp15b/go-steam/trade/tradeapi" +) + +type TradeEndedEvent struct { + Reason TradeEndReason +} + +type TradeEndReason uint + +const ( + TradeEndReason_Complete TradeEndReason = 1 + TradeEndReason_Cancelled = 2 + TradeEndReason_Timeout = 3 + TradeEndReason_Failed = 4 +) + +func newItem(event *tradeapi.Event) *Item { + return &Item{ + event.AppId, + event.ContextId, + event.AssetId, + } +} + +type Item struct { + AppId uint32 + ContextId uint64 + AssetId uint64 +} + +type ItemAddedEvent struct { + Item *Item +} + +type ItemRemovedEvent struct { + Item *Item +} + +type ReadyEvent struct{} +type UnreadyEvent struct{} + +func newCurrency(event *tradeapi.Event) *Currency { + return &Currency{ + event.AppId, + event.ContextId, + event.CurrencyId, + } +} + +type Currency struct { + AppId uint32 + ContextId uint64 + CurrencyId uint64 +} + +type SetCurrencyEvent struct { + Currency *Currency + OldAmount uint64 + NewAmount uint64 +} + +type ChatEvent struct { + Message string +} diff --git a/vendor/github.com/Philipp15b/go-steam/tradeoffer/client.go b/vendor/github.com/Philipp15b/go-steam/tradeoffer/client.go new file mode 100644 index 00000000..7bf171c3 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/tradeoffer/client.go @@ -0,0 +1,452 @@ +package tradeoffer + +import ( + "encoding/json" + "fmt" + "github.com/Philipp15b/go-steam/community" + "github.com/Philipp15b/go-steam/economy/inventory" + "github.com/Philipp15b/go-steam/netutil" + "github.com/Philipp15b/go-steam/steamid" + "io/ioutil" + "net/http" + "strconv" + "time" +) + +type APIKey string + +const apiUrl = "https://api.steampowered.com/IEconService/%s/v%d" + +type Client struct { + client *http.Client + key APIKey + sessionId string +} + +func NewClient(key APIKey, sessionId, steamLogin, steamLoginSecure string) *Client { + c := &Client{ + new(http.Client), + key, + sessionId, + } + community.SetCookies(c.client, sessionId, steamLogin, steamLoginSecure) + return c +} + +func (c *Client) GetOffer(offerId uint64) (*TradeOfferResult, error) { + resp, err := c.client.Get(fmt.Sprintf(apiUrl, "GetTradeOffer", 1) + "?" + netutil.ToUrlValues(map[string]string{ + "key": string(c.key), + "tradeofferid": strconv.FormatUint(offerId, 10), + "language": "en_us", + }).Encode()) + if err != nil { + return nil, err + } + defer resp.Body.Close() + t := new(struct { + Response *TradeOfferResult + }) + if err = json.NewDecoder(resp.Body).Decode(t); err != nil { + return nil, err + } + if t.Response == nil || t.Response.Offer == nil { + return nil, newSteamErrorf("steam returned empty offer result\n") + } + + return t.Response, nil +} + +func (c *Client) GetOffers(getSent bool, getReceived bool, getDescriptions bool, activeOnly bool, historicalOnly bool, timeHistoricalCutoff *uint32) (*TradeOffersResult, error) { + if !getSent && !getReceived { + return nil, fmt.Errorf("getSent and getReceived can't be both false\n") + } + + params := map[string]string{ + "key": string(c.key), + } + if getSent { + params["get_sent_offers"] = "1" + } + if getReceived { + params["get_received_offers"] = "1" + } + if getDescriptions { + params["get_descriptions"] = "1" + params["language"] = "en_us" + } + if activeOnly { + params["active_only"] = "1" + } + if historicalOnly { + params["historical_only"] = "1" + } + if timeHistoricalCutoff != nil { + params["time_historical_cutoff"] = strconv.FormatUint(uint64(*timeHistoricalCutoff), 10) + } + resp, err := c.client.Get(fmt.Sprintf(apiUrl, "GetTradeOffers", 1) + "?" + netutil.ToUrlValues(params).Encode()) + if err != nil { + return nil, err + } + defer resp.Body.Close() + t := new(struct { + Response *TradeOffersResult + }) + if err = json.NewDecoder(resp.Body).Decode(t); err != nil { + return nil, err + } + if t.Response == nil { + return nil, newSteamErrorf("steam returned empty offers result\n") + } + return t.Response, nil +} + +// action() is used by Decline() and Cancel() +// Steam only return success and error fields for malformed requests, +// hence client shall use GetOffer() to check action result +// It is also possible to implement Decline/Cancel using steamcommunity, +// which have more predictable responses +func (c *Client) action(method string, version uint, offerId uint64) error { + resp, err := c.client.Do(netutil.NewPostForm(fmt.Sprintf(apiUrl, method, version), netutil.ToUrlValues(map[string]string{ + "key": string(c.key), + "tradeofferid": strconv.FormatUint(offerId, 10), + }))) + if err != nil { + return err + } + defer resp.Body.Close() + if resp.StatusCode != 200 { + return fmt.Errorf(method+" error: status code %d", resp.StatusCode) + } + return nil +} + +func (c *Client) Decline(offerId uint64) error { + return c.action("DeclineTradeOffer", 1, offerId) +} + +func (c *Client) Cancel(offerId uint64) error { + return c.action("CancelTradeOffer", 1, offerId) +} + +// Accept received trade offer +// It is best to confirm that offer was actually accepted +// by calling GetOffer after Accept and checking offer state +func (c *Client) Accept(offerId uint64) error { + baseurl := fmt.Sprintf("https://steamcommunity.com/tradeoffer/%d/", offerId) + req := netutil.NewPostForm(baseurl+"accept", netutil.ToUrlValues(map[string]string{ + "sessionid": c.sessionId, + "serverid": "1", + "tradeofferid": strconv.FormatUint(offerId, 10), + })) + req.Header.Add("Referer", baseurl) + + resp, err := c.client.Do(req) + if err != nil { + return err + } + defer resp.Body.Close() + t := new(struct { + StrError string `json:"strError"` + }) + if err = json.NewDecoder(resp.Body).Decode(t); err != nil { + return err + } + if t.StrError != "" { + return newSteamErrorf("accept error: %v\n", t.StrError) + } + if resp.StatusCode != 200 { + return fmt.Errorf("accept error: status code %d", resp.StatusCode) + } + return nil +} + +type TradeItem struct { + AppId uint32 `json:"appid"` + ContextId uint64 `json:"contextid,string"` + Amount uint64 `json:"amount"` + AssetId uint64 `json:"assetid,string,omitempty"` + CurrencyId uint64 `json:"currencyid,string,omitempty"` +} + +// Sends a new trade offer to the given Steam user. You can optionally specify an access token if you've got one. +// In addition, `counteredOfferId` can be non-nil, indicating the trade offer this is a counter for. +// On success returns trade offer id +func (c *Client) Create(other steamid.SteamId, accessToken *string, myItems, theirItems []TradeItem, counteredOfferId *uint64, message string) (uint64, error) { + // Create new trade offer status + to := map[string]interface{}{ + "newversion": true, + "version": 3, + "me": map[string]interface{}{ + "assets": myItems, + "currency": make([]struct{}, 0), + "ready": false, + }, + "them": map[string]interface{}{ + "assets": theirItems, + "currency": make([]struct{}, 0), + "ready": false, + }, + } + + jto, err := json.Marshal(to) + if err != nil { + panic(err) + } + + // Create url parameters for request + data := map[string]string{ + "sessionid": c.sessionId, + "serverid": "1", + "partner": other.ToString(), + "tradeoffermessage": message, + "json_tradeoffer": string(jto), + } + + var referer string + if counteredOfferId != nil { + referer = fmt.Sprintf("https://steamcommunity.com/tradeoffer/%d/", *counteredOfferId) + data["tradeofferid_countered"] = strconv.FormatUint(*counteredOfferId, 10) + } else { + // Add token for non-friend offers + if accessToken != nil { + params := map[string]string{ + "trade_offer_access_token": *accessToken, + } + paramsJson, err := json.Marshal(params) + if err != nil { + panic(err) + } + + data["trade_offer_create_params"] = string(paramsJson) + + referer = "https://steamcommunity.com/tradeoffer/new/?partner=" + strconv.FormatUint(uint64(other.GetAccountId()), 10) + "&token=" + *accessToken + } else { + + referer = "https://steamcommunity.com/tradeoffer/new/?partner=" + strconv.FormatUint(uint64(other.GetAccountId()), 10) + } + } + + // Create request + req := netutil.NewPostForm("https://steamcommunity.com/tradeoffer/new/send", netutil.ToUrlValues(data)) + req.Header.Add("Referer", referer) + + // Send request + resp, err := c.client.Do(req) + if err != nil { + return 0, err + } + defer resp.Body.Close() + t := new(struct { + StrError string `json:"strError"` + TradeOfferId uint64 `json:"tradeofferid,string"` + }) + if err = json.NewDecoder(resp.Body).Decode(t); err != nil { + return 0, err + } + // strError code descriptions: + // 15 invalide trade access token + // 16 timeout + // 20 wrong contextid + // 25 can't send more offers until some is accepted/cancelled... + // 26 object is not in our inventory + // error code names are in internal/steamlang/enums.go EResult_name + if t.StrError != "" { + return 0, newSteamErrorf("create error: %v\n", t.StrError) + } + if resp.StatusCode != 200 { + return 0, fmt.Errorf("create error: status code %d", resp.StatusCode) + } + if t.TradeOfferId == 0 { + return 0, newSteamErrorf("create error: steam returned 0 for trade offer id") + } + return t.TradeOfferId, nil +} + +func (c *Client) GetOwnInventory(contextId uint64, appId uint32) (*inventory.Inventory, error) { + return inventory.GetOwnInventory(c.client, contextId, appId) +} + +func (c *Client) GetPartnerInventory(other steamid.SteamId, contextId uint64, appId uint32, offerId *uint64) (*inventory.Inventory, error) { + return inventory.GetFullInventory(func() (*inventory.PartialInventory, error) { + return c.getPartialPartnerInventory(other, contextId, appId, offerId, nil) + }, func(start uint) (*inventory.PartialInventory, error) { + return c.getPartialPartnerInventory(other, contextId, appId, offerId, &start) + }) +} + +func (c *Client) getPartialPartnerInventory(other steamid.SteamId, contextId uint64, appId uint32, offerId *uint64, start *uint) (*inventory.PartialInventory, error) { + data := map[string]string{ + "sessionid": c.sessionId, + "partner": other.ToString(), + "contextid": strconv.FormatUint(contextId, 10), + "appid": strconv.FormatUint(uint64(appId), 10), + } + if start != nil { + data["start"] = strconv.FormatUint(uint64(*start), 10) + } + + baseUrl := "https://steamcommunity.com/tradeoffer/%v/" + if offerId != nil { + baseUrl = fmt.Sprintf(baseUrl, *offerId) + } else { + baseUrl = fmt.Sprintf(baseUrl, "new") + } + + req, err := http.NewRequest("GET", baseUrl+"partnerinventory/?"+netutil.ToUrlValues(data).Encode(), nil) + if err != nil { + panic(err) + } + req.Header.Add("Referer", baseUrl+"?partner="+strconv.FormatUint(uint64(other.GetAccountId()), 10)) + + return inventory.DoInventoryRequest(c.client, req) +} + +// Can be used to verify accepted tradeoffer and find out received asset ids +func (c *Client) GetTradeReceipt(tradeId uint64) ([]*TradeReceiptItem, error) { + url := fmt.Sprintf("https://steamcommunity.com/trade/%d/receipt", tradeId) + resp, err := c.client.Get(url) + if err != nil { + return nil, err + } + defer resp.Body.Close() + respBody, err := ioutil.ReadAll(resp.Body) + if err != nil { + return nil, err + } + items, err := parseTradeReceipt(respBody) + if err != nil { + return nil, newSteamErrorf("failed to parse trade receipt: %v", err) + } + return items, nil +} + +// Get duration of escrow in days. Call this before sending a trade offer +func (c *Client) GetPartnerEscrowDuration(other steamid.SteamId, accessToken *string) (*EscrowDuration, error) { + data := map[string]string{ + "partner": strconv.FormatUint(uint64(other.GetAccountId()), 10), + } + if accessToken != nil { + data["token"] = *accessToken + } + return c.getEscrowDuration("https://steamcommunity.com/tradeoffer/new/?" + netutil.ToUrlValues(data).Encode()) +} + +// Get duration of escrow in days. Call this after receiving a trade offer +func (c *Client) GetOfferEscrowDuration(offerId uint64) (*EscrowDuration, error) { + return c.getEscrowDuration("http://steamcommunity.com/tradeoffer/" + strconv.FormatUint(offerId, 10)) +} + +func (c *Client) getEscrowDuration(queryUrl string) (*EscrowDuration, error) { + resp, err := c.client.Get(queryUrl) + if err != nil { + return nil, fmt.Errorf("failed to retrieve escrow duration: %v", err) + } + defer resp.Body.Close() + respBody, err := ioutil.ReadAll(resp.Body) + if err != nil { + return nil, err + } + escrowDuration, err := parseEscrowDuration(respBody) + if err != nil { + return nil, newSteamErrorf("failed to parse escrow duration: %v", err) + } + return escrowDuration, nil +} + +func (c *Client) GetOfferWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) (*TradeOfferResult, error) { + var res *TradeOfferResult + return res, withRetry( + func() (err error) { + res, err = c.GetOffer(offerId) + return err + }, retryCount, retryDelay) +} + +func (c *Client) GetOffersWithRetry(getSent bool, getReceived bool, getDescriptions bool, activeOnly bool, historicalOnly bool, timeHistoricalCutoff *uint32, retryCount int, retryDelay time.Duration) (*TradeOffersResult, error) { + var res *TradeOffersResult + return res, withRetry( + func() (err error) { + res, err = c.GetOffers(getSent, getReceived, getDescriptions, activeOnly, historicalOnly, timeHistoricalCutoff) + return err + }, retryCount, retryDelay) +} + +func (c *Client) DeclineWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) error { + return withRetry( + func() error { + return c.Decline(offerId) + }, retryCount, retryDelay) +} + +func (c *Client) CancelWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) error { + return withRetry( + func() error { + return c.Cancel(offerId) + }, retryCount, retryDelay) +} + +func (c *Client) AcceptWithRetry(offerId uint64, retryCount int, retryDelay time.Duration) error { + return withRetry( + func() error { + return c.Accept(offerId) + }, retryCount, retryDelay) +} + +func (c *Client) CreateWithRetry(other steamid.SteamId, accessToken *string, myItems, theirItems []TradeItem, counteredOfferId *uint64, message string, retryCount int, retryDelay time.Duration) (uint64, error) { + var res uint64 + return res, withRetry( + func() (err error) { + res, err = c.Create(other, accessToken, myItems, theirItems, counteredOfferId, message) + return err + }, retryCount, retryDelay) +} + +func (c *Client) GetOwnInventoryWithRetry(contextId uint64, appId uint32, retryCount int, retryDelay time.Duration) (*inventory.Inventory, error) { + var res *inventory.Inventory + return res, withRetry( + func() (err error) { + res, err = c.GetOwnInventory(contextId, appId) + return err + }, retryCount, retryDelay) +} + +func (c *Client) GetPartnerInventoryWithRetry(other steamid.SteamId, contextId uint64, appId uint32, offerId *uint64, retryCount int, retryDelay time.Duration) (*inventory.Inventory, error) { + var res *inventory.Inventory + return res, withRetry( + func() (err error) { + res, err = c.GetPartnerInventory(other, contextId, appId, offerId) + return err + }, retryCount, retryDelay) +} + +func (c *Client) GetTradeReceiptWithRetry(tradeId uint64, retryCount int, retryDelay time.Duration) ([]*TradeReceiptItem, error) { + var res []*TradeReceiptItem + return res, withRetry( + func() (err error) { + res, err = c.GetTradeReceipt(tradeId) + return err + }, retryCount, retryDelay) +} + +func withRetry(f func() error, retryCount int, retryDelay time.Duration) error { + if retryCount <= 0 { + panic("retry count must be more than 0") + } + i := 0 + for { + i++ + if err := f(); err != nil { + // If we got steam error do not retry + if _, ok := err.(*SteamError); ok { + return err + } + if i == retryCount { + return err + } + time.Sleep(retryDelay) + continue + } + break + } + return nil +} diff --git a/vendor/github.com/Philipp15b/go-steam/tradeoffer/error.go b/vendor/github.com/Philipp15b/go-steam/tradeoffer/error.go new file mode 100644 index 00000000..439ee69c --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/tradeoffer/error.go @@ -0,0 +1,19 @@ +package tradeoffer + +import ( + "fmt" +) + +// SteamError can be returned by Create, Accept, Decline and Cancel methods. +// It means we got response from steam, but it was in unknown format +// or request was declined. +type SteamError struct { + msg string +} + +func (e *SteamError) Error() string { + return e.msg +} +func newSteamErrorf(format string, a ...interface{}) *SteamError { + return &SteamError{fmt.Sprintf(format, a...)} +} diff --git a/vendor/github.com/Philipp15b/go-steam/tradeoffer/escrow.go b/vendor/github.com/Philipp15b/go-steam/tradeoffer/escrow.go new file mode 100644 index 00000000..07806716 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/tradeoffer/escrow.go @@ -0,0 +1,47 @@ +package tradeoffer + +import ( + "errors" + "fmt" + "regexp" + "strconv" +) + +type EscrowDuration struct { + DaysMyEscrow uint32 + DaysTheirEscrow uint32 +} + +func parseEscrowDuration(data []byte) (*EscrowDuration, error) { + // TODO: why we are using case insensitive matching? + myRegex := regexp.MustCompile("(?i)g_daysMyEscrow[\\s=]+(\\d+);") + theirRegex := regexp.MustCompile("(?i)g_daysTheirEscrow[\\s=]+(\\d+);") + + myM := myRegex.FindSubmatch(data) + theirM := theirRegex.FindSubmatch(data) + + if myM == nil || theirM == nil { + // check if access token is valid + notFriendsRegex := regexp.MustCompile(">You are not friends with this user<") + notFriendsM := notFriendsRegex.FindSubmatch(data) + if notFriendsM == nil { + return nil, errors.New("regexp does not match") + } else { + return nil, errors.New("you are not friends with this user") + } + } + + myEscrow, err := strconv.ParseUint(string(myM[1]), 10, 32) + if err != nil { + return nil, fmt.Errorf("failed to parse my duration into uint: %v", err) + } + theirEscrow, err := strconv.ParseUint(string(theirM[1]), 10, 32) + if err != nil { + return nil, fmt.Errorf("failed to parse their duration into uint: %v", err) + } + + return &EscrowDuration{ + DaysMyEscrow: uint32(myEscrow), + DaysTheirEscrow: uint32(theirEscrow), + }, nil +} diff --git a/vendor/github.com/Philipp15b/go-steam/tradeoffer/receipt.go b/vendor/github.com/Philipp15b/go-steam/tradeoffer/receipt.go new file mode 100644 index 00000000..3f4b556d --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/tradeoffer/receipt.go @@ -0,0 +1,35 @@ +package tradeoffer + +import ( + "encoding/json" + "fmt" + "github.com/Philipp15b/go-steam/economy/inventory" + "regexp" +) + +type TradeReceiptItem struct { + AssetId uint64 `json:"id,string"` + AppId uint32 + ContextId uint64 + Owner uint64 `json:",string"` + Pos uint32 + inventory.Description +} + +func parseTradeReceipt(data []byte) ([]*TradeReceiptItem, error) { + reg := regexp.MustCompile("oItem =\\s+(.+?});") + itemMatches := reg.FindAllSubmatch(data, -1) + if itemMatches == nil { + return nil, fmt.Errorf("items not found\n") + } + items := make([]*TradeReceiptItem, 0, len(itemMatches)) + for _, m := range itemMatches { + item := new(TradeReceiptItem) + err := json.Unmarshal(m[1], &item) + if err != nil { + return nil, err + } + items = append(items, item) + } + return items, nil +} diff --git a/vendor/github.com/Philipp15b/go-steam/tradeoffer/tradeoffer.go b/vendor/github.com/Philipp15b/go-steam/tradeoffer/tradeoffer.go new file mode 100644 index 00000000..1cf3aaa3 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/tradeoffer/tradeoffer.go @@ -0,0 +1,118 @@ +/* +Implements methods to interact with the official Trade Offer API. + +See: https://developer.valvesoftware.com/wiki/Steam_Web_API/IEconService +*/ +package tradeoffer + +import ( + "encoding/json" + "github.com/Philipp15b/go-steam/economy/inventory" + "github.com/Philipp15b/go-steam/steamid" +) + +type TradeOfferState uint + +const ( + TradeOfferState_Invalid TradeOfferState = 1 // Invalid + TradeOfferState_Active = 2 // This trade offer has been sent, neither party has acted on it yet. + TradeOfferState_Accepted = 3 // The trade offer was accepted by the recipient and items were exchanged. + TradeOfferState_Countered = 4 // The recipient made a counter offer + TradeOfferState_Expired = 5 // The trade offer was not accepted before the expiration date + TradeOfferState_Canceled = 6 // The sender cancelled the offer + TradeOfferState_Declined = 7 // The recipient declined the offer + TradeOfferState_InvalidItems = 8 // Some of the items in the offer are no longer available (indicated by the missing flag in the output) + TradeOfferState_CreatedNeedsConfirmation = 9 // The offer hasn't been sent yet and is awaiting email/mobile confirmation. The offer is only visible to the sender. + TradeOfferState_CanceledBySecondFactor = 10 // Either party canceled the offer via email/mobile. The offer is visible to both parties, even if the sender canceled it before it was sent. + TradeOfferState_InEscrow = 11 // The trade has been placed on hold. The items involved in the trade have all been removed from both parties' inventories and will be automatically delivered in the future. +) + +type TradeOfferConfirmationMethod uint + +const ( + TradeOfferConfirmationMethod_Invalid TradeOfferConfirmationMethod = 0 + TradeOfferConfirmationMethod_Email = 1 + TradeOfferConfirmationMethod_MobileApp = 2 +) + +type Asset struct { + AppId uint32 `json:",string"` + ContextId uint64 `json:",string"` + AssetId uint64 `json:",string"` + CurrencyId uint64 `json:",string"` + ClassId uint64 `json:",string"` + InstanceId uint64 `json:",string"` + Amount uint64 `json:",string"` + Missing bool +} + +type TradeOffer struct { + TradeOfferId uint64 `json:",string"` + TradeId uint64 `json:",string"` + OtherAccountId uint32 `json:"accountid_other"` + OtherSteamId steamid.SteamId `json:"-"` + Message string `json:"message"` + ExpirationTime uint32 `json:"expiraton_time"` + State TradeOfferState `json:"trade_offer_state"` + ToGive []*Asset `json:"items_to_give"` + ToReceive []*Asset `json:"items_to_receive"` + IsOurOffer bool `json:"is_our_offer"` + TimeCreated uint32 `json:"time_created"` + TimeUpdated uint32 `json:"time_updated"` + EscrowEndDate uint32 `json:"escrow_end_date"` + ConfirmationMethod TradeOfferConfirmationMethod `json:"confirmation_method"` +} + +func (t *TradeOffer) UnmarshalJSON(data []byte) error { + type Alias TradeOffer + aux := struct { + *Alias + }{ + Alias: (*Alias)(t), + } + if err := json.Unmarshal(data, &aux); err != nil { + return err + } + if t.OtherAccountId == 0 { + t.OtherSteamId = steamid.SteamId(0) + return nil + } + t.OtherSteamId = steamid.SteamId(uint64(t.OtherAccountId) + 76561197960265728) + return nil +} + +type TradeOffersResult struct { + Sent []*TradeOffer `json:"trade_offers_sent"` + Received []*TradeOffer `json:"trade_offers_received"` + Descriptions []*Description +} + +type TradeOfferResult struct { + Offer *TradeOffer + Descriptions []*Description +} +type Description struct { + AppId uint32 `json:"appid"` + ClassId uint64 `json:"classid,string"` + InstanceId uint64 `json:"instanceid,string"` + + IconUrl string `json:"icon_url"` + IconUrlLarge string `json:"icon_url_large"` + + Name string + MarketName string `json:"market_name"` + MarketHashName string `json:"market_hash_name"` + + // Colors in hex, for example `B2B2B2` + NameColor string `json:"name_color"` + BackgroundColor string `json:"background_color"` + + Type string + + Tradable bool `json:"tradable"` + Commodity bool `json:"commodity"` + MarketTradableRestriction uint32 `json:"market_tradable_restriction"` + + Descriptions inventory.DescriptionLines `json:"descriptions"` + Actions []*inventory.Action `json:"actions"` +} diff --git a/vendor/github.com/Philipp15b/go-steam/trading.go b/vendor/github.com/Philipp15b/go-steam/trading.go new file mode 100644 index 00000000..10995d7a --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/trading.go @@ -0,0 +1,83 @@ +package steam + +import ( + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" + "github.com/golang/protobuf/proto" +) + +// Provides access to the Steam client's part of Steam Trading, that is bootstrapping +// the trade. +// The trade itself is not handled by the Steam client itself, but it's a part of +// the Steam website. +// +// You'll receive a TradeProposedEvent when a friend proposes a trade. You can accept it with +// the RespondRequest method. You can request a trade yourself with RequestTrade. +type Trading struct { + client *Client +} + +type TradeRequestId uint32 + +func (t *Trading) HandlePacket(packet *Packet) { + switch packet.EMsg { + case EMsg_EconTrading_InitiateTradeProposed: + msg := new(CMsgTrading_InitiateTradeRequest) + packet.ReadProtoMsg(msg) + t.client.Emit(&TradeProposedEvent{ + RequestId: TradeRequestId(msg.GetTradeRequestId()), + Other: SteamId(msg.GetOtherSteamid()), + }) + case EMsg_EconTrading_InitiateTradeResult: + msg := new(CMsgTrading_InitiateTradeResponse) + packet.ReadProtoMsg(msg) + t.client.Emit(&TradeResultEvent{ + RequestId: TradeRequestId(msg.GetTradeRequestId()), + Response: EEconTradeResponse(msg.GetResponse()), + Other: SteamId(msg.GetOtherSteamid()), + + NumDaysSteamGuardRequired: msg.GetSteamguardRequiredDays(), + NumDaysNewDeviceCooldown: msg.GetNewDeviceCooldownDays(), + DefaultNumDaysPasswordResetProbation: msg.GetDefaultPasswordResetProbationDays(), + NumDaysPasswordResetProbation: msg.GetPasswordResetProbationDays(), + }) + case EMsg_EconTrading_StartSession: + msg := new(CMsgTrading_StartSession) + packet.ReadProtoMsg(msg) + t.client.Emit(&TradeSessionStartEvent{ + Other: SteamId(msg.GetOtherSteamid()), + }) + } +} + +// Requests a trade. You'll receive a TradeResultEvent if the request fails or +// if the friend accepted the trade. +func (t *Trading) RequestTrade(other SteamId) { + t.client.Write(NewClientMsgProtobuf(EMsg_EconTrading_InitiateTradeRequest, &CMsgTrading_InitiateTradeRequest{ + OtherSteamid: proto.Uint64(uint64(other)), + })) +} + +// Responds to a TradeProposedEvent. +func (t *Trading) RespondRequest(requestId TradeRequestId, accept bool) { + var resp uint32 + if accept { + resp = 0 + } else { + resp = 1 + } + + t.client.Write(NewClientMsgProtobuf(EMsg_EconTrading_InitiateTradeResponse, &CMsgTrading_InitiateTradeResponse{ + TradeRequestId: proto.Uint32(uint32(requestId)), + Response: proto.Uint32(resp), + })) +} + +// This cancels a request made with RequestTrade. +func (t *Trading) CancelRequest(other SteamId) { + t.client.Write(NewClientMsgProtobuf(EMsg_EconTrading_CancelTradeRequest, &CMsgTrading_CancelTradeRequest{ + OtherSteamid: proto.Uint64(uint64(other)), + })) +} diff --git a/vendor/github.com/Philipp15b/go-steam/trading_events.go b/vendor/github.com/Philipp15b/go-steam/trading_events.go new file mode 100644 index 00000000..c9597d33 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/trading_events.go @@ -0,0 +1,29 @@ +package steam + +import ( + . "github.com/Philipp15b/go-steam/protocol/steamlang" + . "github.com/Philipp15b/go-steam/steamid" +) + +type TradeProposedEvent struct { + RequestId TradeRequestId + Other SteamId `json:",string"` +} + +type TradeResultEvent struct { + RequestId TradeRequestId + Response EEconTradeResponse + Other SteamId `json:",string"` + // Number of days Steam Guard is required to have been active + NumDaysSteamGuardRequired uint32 + // Number of days a new device cannot trade for. + NumDaysNewDeviceCooldown uint32 + // Default number of days one cannot trade after a password reset. + DefaultNumDaysPasswordResetProbation uint32 + // See above. + NumDaysPasswordResetProbation uint32 +} + +type TradeSessionStartEvent struct { + Other SteamId `json:",string"` +} diff --git a/vendor/github.com/Philipp15b/go-steam/web.go b/vendor/github.com/Philipp15b/go-steam/web.go new file mode 100644 index 00000000..0b14db2c --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/web.go @@ -0,0 +1,143 @@ +package steam + +import ( + "crypto/aes" + "crypto/rand" + "encoding/base64" + "encoding/json" + "errors" + "github.com/Philipp15b/go-steam/cryptoutil" + . "github.com/Philipp15b/go-steam/protocol" + . "github.com/Philipp15b/go-steam/protocol/protobuf" + . "github.com/Philipp15b/go-steam/protocol/steamlang" + "github.com/golang/protobuf/proto" + "net/http" + "net/url" + "strconv" + "sync/atomic" +) + +type Web struct { + // 64 bit alignment + relogOnNonce uint32 + + // The `sessionid` cookie required to use the steam website. + // This cookie may contain a characters that will need to be URL-escaped, otherwise + // Steam (probably) interprets is as a string. + // When used as an URL paramter this is automatically escaped by the Go HTTP package. + SessionId string + // The `steamLogin` cookie required to use the steam website. Already URL-escaped. + // This is only available after calling LogOn(). + SteamLogin string + // The `steamLoginSecure` cookie required to use the steam website over HTTPs. Already URL-escaped. + // This is only availbile after calling LogOn(). + SteamLoginSecure string + + webLoginKey string + + client *Client +} + +func (w *Web) HandlePacket(packet *Packet) { + switch packet.EMsg { + case EMsg_ClientNewLoginKey: + w.handleNewLoginKey(packet) + case EMsg_ClientRequestWebAPIAuthenticateUserNonceResponse: + w.handleAuthNonceResponse(packet) + } +} + +// Fetches the `steamLogin` cookie. This may only be called after the first +// WebSessionIdEvent or it will panic. +func (w *Web) LogOn() { + if w.webLoginKey == "" { + panic("Web: webLoginKey not initialized!") + } + + go func() { + // retry three times. yes, I know about loops. + err := w.apiLogOn() + if err != nil { + err = w.apiLogOn() + if err != nil { + err = w.apiLogOn() + } + } + if err != nil { + w.client.Emit(WebLogOnErrorEvent(err)) + return + } + }() +} + +func (w *Web) apiLogOn() error { + sessionKey := make([]byte, 32) + rand.Read(sessionKey) + + cryptedSessionKey := cryptoutil.RSAEncrypt(GetPublicKey(EUniverse_Public), sessionKey) + ciph, _ := aes.NewCipher(sessionKey) + cryptedLoginKey := cryptoutil.SymmetricEncrypt(ciph, []byte(w.webLoginKey)) + data := make(url.Values) + data.Add("format", "json") + data.Add("steamid", strconv.FormatUint(w.client.SteamId().ToUint64(), 10)) + data.Add("sessionkey", string(cryptedSessionKey)) + data.Add("encrypted_loginkey", string(cryptedLoginKey)) + resp, err := http.PostForm("https://api.steampowered.com/ISteamUserAuth/AuthenticateUser/v0001", data) + if err != nil { + return err + } + defer resp.Body.Close() + + if resp.StatusCode == 401 { + // our web login key has expired, request a new one + atomic.StoreUint32(&w.relogOnNonce, 1) + w.client.Write(NewClientMsgProtobuf(EMsg_ClientRequestWebAPIAuthenticateUserNonce, new(CMsgClientRequestWebAPIAuthenticateUserNonce))) + return nil + } else if resp.StatusCode != 200 { + return errors.New("steam.Web.apiLogOn: request failed with status " + resp.Status) + } + + result := new(struct { + Authenticateuser struct { + Token string + TokenSecure string + } + }) + err = json.NewDecoder(resp.Body).Decode(result) + if err != nil { + return err + } + + w.SteamLogin = result.Authenticateuser.Token + w.SteamLoginSecure = result.Authenticateuser.TokenSecure + + w.client.Emit(new(WebLoggedOnEvent)) + return nil +} + +func (w *Web) handleNewLoginKey(packet *Packet) { + msg := new(CMsgClientNewLoginKey) + packet.ReadProtoMsg(msg) + + w.client.Write(NewClientMsgProtobuf(EMsg_ClientNewLoginKeyAccepted, &CMsgClientNewLoginKeyAccepted{ + UniqueId: proto.Uint32(msg.GetUniqueId()), + })) + + // number -> string -> bytes -> base64 + w.SessionId = base64.StdEncoding.EncodeToString([]byte(strconv.FormatUint(uint64(msg.GetUniqueId()), 10))) + + w.client.Emit(new(WebSessionIdEvent)) +} + +func (w *Web) handleAuthNonceResponse(packet *Packet) { + // this has to be the best name for a message yet. + msg := new(CMsgClientRequestWebAPIAuthenticateUserNonceResponse) + packet.ReadProtoMsg(msg) + w.webLoginKey = msg.GetWebapiAuthenticateUserNonce() + + // if the nonce was specifically requested in apiLogOn(), + // don't emit an event. + if atomic.CompareAndSwapUint32(&w.relogOnNonce, 1, 0) { + w.LogOn() + } +} diff --git a/vendor/github.com/Philipp15b/go-steam/web_events.go b/vendor/github.com/Philipp15b/go-steam/web_events.go new file mode 100644 index 00000000..18056469 --- /dev/null +++ b/vendor/github.com/Philipp15b/go-steam/web_events.go @@ -0,0 +1,7 @@ +package steam + +type WebLoggedOnEvent struct{} + +type WebLogOnErrorEvent error + +type WebSessionIdEvent struct{} diff --git a/vendor/github.com/davecgh/go-spew/spew/LICENSE b/vendor/github.com/davecgh/go-spew/spew/LICENSE new file mode 100644 index 00000000..c8364161 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/LICENSE @@ -0,0 +1,15 @@ +ISC License + +Copyright (c) 2012-2016 Dave Collins + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go new file mode 100644 index 00000000..8a4a6589 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/bypass.go @@ -0,0 +1,152 @@ +// Copyright (c) 2015-2016 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when the code is not running on Google App Engine, compiled by GopherJS, and +// "-tags safe" is not added to the go build command line. The "disableunsafe" +// tag is deprecated and thus should not be used. +// +build !js,!appengine,!safe,!disableunsafe + +package spew + +import ( + "reflect" + "unsafe" +) + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = false + + // ptrSize is the size of a pointer on the current arch. + ptrSize = unsafe.Sizeof((*byte)(nil)) +) + +var ( + // offsetPtr, offsetScalar, and offsetFlag are the offsets for the + // internal reflect.Value fields. These values are valid before golang + // commit ecccf07e7f9d which changed the format. The are also valid + // after commit 82f48826c6c7 which changed the format again to mirror + // the original format. Code in the init function updates these offsets + // as necessary. + offsetPtr = uintptr(ptrSize) + offsetScalar = uintptr(0) + offsetFlag = uintptr(ptrSize * 2) + + // flagKindWidth and flagKindShift indicate various bits that the + // reflect package uses internally to track kind information. + // + // flagRO indicates whether or not the value field of a reflect.Value is + // read-only. + // + // flagIndir indicates whether the value field of a reflect.Value is + // the actual data or a pointer to the data. + // + // These values are valid before golang commit 90a7c3c86944 which + // changed their positions. Code in the init function updates these + // flags as necessary. + flagKindWidth = uintptr(5) + flagKindShift = uintptr(flagKindWidth - 1) + flagRO = uintptr(1 << 0) + flagIndir = uintptr(1 << 1) +) + +func init() { + // Older versions of reflect.Value stored small integers directly in the + // ptr field (which is named val in the older versions). Versions + // between commits ecccf07e7f9d and 82f48826c6c7 added a new field named + // scalar for this purpose which unfortunately came before the flag + // field, so the offset of the flag field is different for those + // versions. + // + // This code constructs a new reflect.Value from a known small integer + // and checks if the size of the reflect.Value struct indicates it has + // the scalar field. When it does, the offsets are updated accordingly. + vv := reflect.ValueOf(0xf00) + if unsafe.Sizeof(vv) == (ptrSize * 4) { + offsetScalar = ptrSize * 2 + offsetFlag = ptrSize * 3 + } + + // Commit 90a7c3c86944 changed the flag positions such that the low + // order bits are the kind. This code extracts the kind from the flags + // field and ensures it's the correct type. When it's not, the flag + // order has been changed to the newer format, so the flags are updated + // accordingly. + upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag) + upfv := *(*uintptr)(upf) + flagKindMask := uintptr((1<>flagKindShift != uintptr(reflect.Int) { + flagKindShift = 0 + flagRO = 1 << 5 + flagIndir = 1 << 6 + + // Commit adf9b30e5594 modified the flags to separate the + // flagRO flag into two bits which specifies whether or not the + // field is embedded. This causes flagIndir to move over a bit + // and means that flagRO is the combination of either of the + // original flagRO bit and the new bit. + // + // This code detects the change by extracting what used to be + // the indirect bit to ensure it's set. When it's not, the flag + // order has been changed to the newer format, so the flags are + // updated accordingly. + if upfv&flagIndir == 0 { + flagRO = 3 << 5 + flagIndir = 1 << 7 + } + } +} + +// unsafeReflectValue converts the passed reflect.Value into a one that bypasses +// the typical safety restrictions preventing access to unaddressable and +// unexported data. It works by digging the raw pointer to the underlying +// value out of the protected value and generating a new unprotected (unsafe) +// reflect.Value to it. +// +// This allows us to check for implementations of the Stringer and error +// interfaces to be used for pretty printing ordinarily unaddressable and +// inaccessible values such as unexported struct fields. +func unsafeReflectValue(v reflect.Value) (rv reflect.Value) { + indirects := 1 + vt := v.Type() + upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr) + rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag)) + if rvf&flagIndir != 0 { + vt = reflect.PtrTo(v.Type()) + indirects++ + } else if offsetScalar != 0 { + // The value is in the scalar field when it's not one of the + // reference types. + switch vt.Kind() { + case reflect.Uintptr: + case reflect.Chan: + case reflect.Func: + case reflect.Map: + case reflect.Ptr: + case reflect.UnsafePointer: + default: + upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + + offsetScalar) + } + } + + pv := reflect.NewAt(vt, upv) + rv = pv + for i := 0; i < indirects; i++ { + rv = rv.Elem() + } + return rv +} diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go new file mode 100644 index 00000000..1fe3cf3d --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go @@ -0,0 +1,38 @@ +// Copyright (c) 2015-2016 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when the code is running on Google App Engine, compiled by GopherJS, or +// "-tags safe" is added to the go build command line. The "disableunsafe" +// tag is deprecated and thus should not be used. +// +build js appengine safe disableunsafe + +package spew + +import "reflect" + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = true +) + +// unsafeReflectValue typically converts the passed reflect.Value into a one +// that bypasses the typical safety restrictions preventing access to +// unaddressable and unexported data. However, doing this relies on access to +// the unsafe package. This is a stub version which simply returns the passed +// reflect.Value when the unsafe package is not available. +func unsafeReflectValue(v reflect.Value) reflect.Value { + return v +} diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go new file mode 100644 index 00000000..7c519ff4 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/common.go @@ -0,0 +1,341 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "reflect" + "sort" + "strconv" +) + +// Some constants in the form of bytes to avoid string overhead. This mirrors +// the technique used in the fmt package. +var ( + panicBytes = []byte("(PANIC=") + plusBytes = []byte("+") + iBytes = []byte("i") + trueBytes = []byte("true") + falseBytes = []byte("false") + interfaceBytes = []byte("(interface {})") + commaNewlineBytes = []byte(",\n") + newlineBytes = []byte("\n") + openBraceBytes = []byte("{") + openBraceNewlineBytes = []byte("{\n") + closeBraceBytes = []byte("}") + asteriskBytes = []byte("*") + colonBytes = []byte(":") + colonSpaceBytes = []byte(": ") + openParenBytes = []byte("(") + closeParenBytes = []byte(")") + spaceBytes = []byte(" ") + pointerChainBytes = []byte("->") + nilAngleBytes = []byte("") + maxNewlineBytes = []byte("\n") + maxShortBytes = []byte("") + circularBytes = []byte("") + circularShortBytes = []byte("") + invalidAngleBytes = []byte("") + openBracketBytes = []byte("[") + closeBracketBytes = []byte("]") + percentBytes = []byte("%") + precisionBytes = []byte(".") + openAngleBytes = []byte("<") + closeAngleBytes = []byte(">") + openMapBytes = []byte("map[") + closeMapBytes = []byte("]") + lenEqualsBytes = []byte("len=") + capEqualsBytes = []byte("cap=") +) + +// hexDigits is used to map a decimal value to a hex digit. +var hexDigits = "0123456789abcdef" + +// catchPanic handles any panics that might occur during the handleMethods +// calls. +func catchPanic(w io.Writer, v reflect.Value) { + if err := recover(); err != nil { + w.Write(panicBytes) + fmt.Fprintf(w, "%v", err) + w.Write(closeParenBytes) + } +} + +// handleMethods attempts to call the Error and String methods on the underlying +// type the passed reflect.Value represents and outputes the result to Writer w. +// +// It handles panics in any called methods by catching and displaying the error +// as the formatted value. +func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) { + // We need an interface to check if the type implements the error or + // Stringer interface. However, the reflect package won't give us an + // interface on certain things like unexported struct fields in order + // to enforce visibility rules. We use unsafe, when it's available, + // to bypass these restrictions since this package does not mutate the + // values. + if !v.CanInterface() { + if UnsafeDisabled { + return false + } + + v = unsafeReflectValue(v) + } + + // Choose whether or not to do error and Stringer interface lookups against + // the base type or a pointer to the base type depending on settings. + // Technically calling one of these methods with a pointer receiver can + // mutate the value, however, types which choose to satisify an error or + // Stringer interface with a pointer receiver should not be mutating their + // state inside these interface methods. + if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() { + v = unsafeReflectValue(v) + } + if v.CanAddr() { + v = v.Addr() + } + + // Is it an error or Stringer? + switch iface := v.Interface().(type) { + case error: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.Error())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + + w.Write([]byte(iface.Error())) + return true + + case fmt.Stringer: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.String())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + w.Write([]byte(iface.String())) + return true + } + return false +} + +// printBool outputs a boolean value as true or false to Writer w. +func printBool(w io.Writer, val bool) { + if val { + w.Write(trueBytes) + } else { + w.Write(falseBytes) + } +} + +// printInt outputs a signed integer value to Writer w. +func printInt(w io.Writer, val int64, base int) { + w.Write([]byte(strconv.FormatInt(val, base))) +} + +// printUint outputs an unsigned integer value to Writer w. +func printUint(w io.Writer, val uint64, base int) { + w.Write([]byte(strconv.FormatUint(val, base))) +} + +// printFloat outputs a floating point value using the specified precision, +// which is expected to be 32 or 64bit, to Writer w. +func printFloat(w io.Writer, val float64, precision int) { + w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision))) +} + +// printComplex outputs a complex value using the specified float precision +// for the real and imaginary parts to Writer w. +func printComplex(w io.Writer, c complex128, floatPrecision int) { + r := real(c) + w.Write(openParenBytes) + w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision))) + i := imag(c) + if i >= 0 { + w.Write(plusBytes) + } + w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision))) + w.Write(iBytes) + w.Write(closeParenBytes) +} + +// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x' +// prefix to Writer w. +func printHexPtr(w io.Writer, p uintptr) { + // Null pointer. + num := uint64(p) + if num == 0 { + w.Write(nilAngleBytes) + return + } + + // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix + buf := make([]byte, 18) + + // It's simpler to construct the hex string right to left. + base := uint64(16) + i := len(buf) - 1 + for num >= base { + buf[i] = hexDigits[num%base] + num /= base + i-- + } + buf[i] = hexDigits[num] + + // Add '0x' prefix. + i-- + buf[i] = 'x' + i-- + buf[i] = '0' + + // Strip unused leading bytes. + buf = buf[i:] + w.Write(buf) +} + +// valuesSorter implements sort.Interface to allow a slice of reflect.Value +// elements to be sorted. +type valuesSorter struct { + values []reflect.Value + strings []string // either nil or same len and values + cs *ConfigState +} + +// newValuesSorter initializes a valuesSorter instance, which holds a set of +// surrogate keys on which the data should be sorted. It uses flags in +// ConfigState to decide if and how to populate those surrogate keys. +func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface { + vs := &valuesSorter{values: values, cs: cs} + if canSortSimply(vs.values[0].Kind()) { + return vs + } + if !cs.DisableMethods { + vs.strings = make([]string, len(values)) + for i := range vs.values { + b := bytes.Buffer{} + if !handleMethods(cs, &b, vs.values[i]) { + vs.strings = nil + break + } + vs.strings[i] = b.String() + } + } + if vs.strings == nil && cs.SpewKeys { + vs.strings = make([]string, len(values)) + for i := range vs.values { + vs.strings[i] = Sprintf("%#v", vs.values[i].Interface()) + } + } + return vs +} + +// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted +// directly, or whether it should be considered for sorting by surrogate keys +// (if the ConfigState allows it). +func canSortSimply(kind reflect.Kind) bool { + // This switch parallels valueSortLess, except for the default case. + switch kind { + case reflect.Bool: + return true + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return true + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return true + case reflect.Float32, reflect.Float64: + return true + case reflect.String: + return true + case reflect.Uintptr: + return true + case reflect.Array: + return true + } + return false +} + +// Len returns the number of values in the slice. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Len() int { + return len(s.values) +} + +// Swap swaps the values at the passed indices. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Swap(i, j int) { + s.values[i], s.values[j] = s.values[j], s.values[i] + if s.strings != nil { + s.strings[i], s.strings[j] = s.strings[j], s.strings[i] + } +} + +// valueSortLess returns whether the first value should sort before the second +// value. It is used by valueSorter.Less as part of the sort.Interface +// implementation. +func valueSortLess(a, b reflect.Value) bool { + switch a.Kind() { + case reflect.Bool: + return !a.Bool() && b.Bool() + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return a.Int() < b.Int() + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return a.Uint() < b.Uint() + case reflect.Float32, reflect.Float64: + return a.Float() < b.Float() + case reflect.String: + return a.String() < b.String() + case reflect.Uintptr: + return a.Uint() < b.Uint() + case reflect.Array: + // Compare the contents of both arrays. + l := a.Len() + for i := 0; i < l; i++ { + av := a.Index(i) + bv := b.Index(i) + if av.Interface() == bv.Interface() { + continue + } + return valueSortLess(av, bv) + } + } + return a.String() < b.String() +} + +// Less returns whether the value at index i should sort before the +// value at index j. It is part of the sort.Interface implementation. +func (s *valuesSorter) Less(i, j int) bool { + if s.strings == nil { + return valueSortLess(s.values[i], s.values[j]) + } + return s.strings[i] < s.strings[j] +} + +// sortValues is a sort function that handles both native types and any type that +// can be converted to error or Stringer. Other inputs are sorted according to +// their Value.String() value to ensure display stability. +func sortValues(values []reflect.Value, cs *ConfigState) { + if len(values) == 0 { + return + } + sort.Sort(newValuesSorter(values, cs)) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go new file mode 100644 index 00000000..2e3d22f3 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/config.go @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "os" +) + +// ConfigState houses the configuration options used by spew to format and +// display values. There is a global instance, Config, that is used to control +// all top-level Formatter and Dump functionality. Each ConfigState instance +// provides methods equivalent to the top-level functions. +// +// The zero value for ConfigState provides no indentation. You would typically +// want to set it to a space or a tab. +// +// Alternatively, you can use NewDefaultConfig to get a ConfigState instance +// with default settings. See the documentation of NewDefaultConfig for default +// values. +type ConfigState struct { + // Indent specifies the string to use for each indentation level. The + // global config instance that all top-level functions use set this to a + // single space by default. If you would like more indentation, you might + // set this to a tab with "\t" or perhaps two spaces with " ". + Indent string + + // MaxDepth controls the maximum number of levels to descend into nested + // data structures. The default, 0, means there is no limit. + // + // NOTE: Circular data structures are properly detected, so it is not + // necessary to set this value unless you specifically want to limit deeply + // nested data structures. + MaxDepth int + + // DisableMethods specifies whether or not error and Stringer interfaces are + // invoked for types that implement them. + DisableMethods bool + + // DisablePointerMethods specifies whether or not to check for and invoke + // error and Stringer interfaces on types which only accept a pointer + // receiver when the current type is not a pointer. + // + // NOTE: This might be an unsafe action since calling one of these methods + // with a pointer receiver could technically mutate the value, however, + // in practice, types which choose to satisify an error or Stringer + // interface with a pointer receiver should not be mutating their state + // inside these interface methods. As a result, this option relies on + // access to the unsafe package, so it will not have any effect when + // running in environments without access to the unsafe package such as + // Google App Engine or with the "safe" build tag specified. + DisablePointerMethods bool + + // DisablePointerAddresses specifies whether to disable the printing of + // pointer addresses. This is useful when diffing data structures in tests. + DisablePointerAddresses bool + + // DisableCapacities specifies whether to disable the printing of capacities + // for arrays, slices, maps and channels. This is useful when diffing + // data structures in tests. + DisableCapacities bool + + // ContinueOnMethod specifies whether or not recursion should continue once + // a custom error or Stringer interface is invoked. The default, false, + // means it will print the results of invoking the custom error or Stringer + // interface and return immediately instead of continuing to recurse into + // the internals of the data type. + // + // NOTE: This flag does not have any effect if method invocation is disabled + // via the DisableMethods or DisablePointerMethods options. + ContinueOnMethod bool + + // SortKeys specifies map keys should be sorted before being printed. Use + // this to have a more deterministic, diffable output. Note that only + // native types (bool, int, uint, floats, uintptr and string) and types + // that support the error or Stringer interfaces (if methods are + // enabled) are supported, with other types sorted according to the + // reflect.Value.String() output which guarantees display stability. + SortKeys bool + + // SpewKeys specifies that, as a last resort attempt, map keys should + // be spewed to strings and sorted by those strings. This is only + // considered if SortKeys is true. + SpewKeys bool +} + +// Config is the active configuration of the top-level functions. +// The configuration can be changed by modifying the contents of spew.Config. +var Config = ConfigState{Indent: " "} + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the formatted string as a value that satisfies error. See NewFormatter +// for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, c.convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, c.convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, c.convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a Formatter interface returned by c.NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, c.convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Print(a ...interface{}) (n int, err error) { + return fmt.Print(c.convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, c.convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Println(a ...interface{}) (n int, err error) { + return fmt.Println(c.convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprint(a ...interface{}) string { + return fmt.Sprint(c.convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, c.convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a Formatter interface returned by c.NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintln(a ...interface{}) string { + return fmt.Sprintln(c.convertArgs(a)...) +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +c.Printf, c.Println, or c.Printf. +*/ +func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(c, v) +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) { + fdump(c, w, a...) +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by modifying the public members +of c. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func (c *ConfigState) Dump(a ...interface{}) { + fdump(c, os.Stdout, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func (c *ConfigState) Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(c, &buf, a...) + return buf.String() +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a spew Formatter interface using +// the ConfigState associated with s. +func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = newFormatter(c, arg) + } + return formatters +} + +// NewDefaultConfig returns a ConfigState with the following default settings. +// +// Indent: " " +// MaxDepth: 0 +// DisableMethods: false +// DisablePointerMethods: false +// ContinueOnMethod: false +// SortKeys: false +func NewDefaultConfig() *ConfigState { + return &ConfigState{Indent: " "} +} diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go new file mode 100644 index 00000000..aacaac6f --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/doc.go @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* +Package spew implements a deep pretty printer for Go data structures to aid in +debugging. + +A quick overview of the additional features spew provides over the built-in +printing facilities for Go data types are as follows: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output (only when using + Dump style) + +There are two different approaches spew allows for dumping Go data structures: + + * Dump style which prints with newlines, customizable indentation, + and additional debug information such as types and all pointer addresses + used to indirect to the final value + * A custom Formatter interface that integrates cleanly with the standard fmt + package and replaces %v, %+v, %#v, and %#+v to provide inline printing + similar to the default %v while providing the additional functionality + outlined above and passing unsupported format verbs such as %x and %q + along to fmt + +Quick Start + +This section demonstrates how to quickly get started with spew. See the +sections below for further details on formatting and configuration options. + +To dump a variable with full newlines, indentation, type, and pointer +information use Dump, Fdump, or Sdump: + spew.Dump(myVar1, myVar2, ...) + spew.Fdump(someWriter, myVar1, myVar2, ...) + str := spew.Sdump(myVar1, myVar2, ...) + +Alternatively, if you would prefer to use format strings with a compacted inline +printing style, use the convenience wrappers Printf, Fprintf, etc with +%v (most compact), %+v (adds pointer addresses), %#v (adds types), or +%#+v (adds types and pointer addresses): + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +Configuration Options + +Configuration of spew is handled by fields in the ConfigState type. For +convenience, all of the top-level functions use a global state available +via the spew.Config global. + +It is also possible to create a ConfigState instance that provides methods +equivalent to the top-level functions. This allows concurrent configuration +options. See the ConfigState documentation for more details. + +The following configuration options are available: + * Indent + String to use for each indentation level for Dump functions. + It is a single space by default. A popular alternative is "\t". + + * MaxDepth + Maximum number of levels to descend into nested data structures. + There is no limit by default. + + * DisableMethods + Disables invocation of error and Stringer interface methods. + Method invocation is enabled by default. + + * DisablePointerMethods + Disables invocation of error and Stringer interface methods on types + which only accept pointer receivers from non-pointer variables. + Pointer method invocation is enabled by default. + + * DisablePointerAddresses + DisablePointerAddresses specifies whether to disable the printing of + pointer addresses. This is useful when diffing data structures in tests. + + * DisableCapacities + DisableCapacities specifies whether to disable the printing of + capacities for arrays, slices, maps and channels. This is useful when + diffing data structures in tests. + + * ContinueOnMethod + Enables recursion into types after invoking error and Stringer interface + methods. Recursion after method invocation is disabled by default. + + * SortKeys + Specifies map keys should be sorted before being printed. Use + this to have a more deterministic, diffable output. Note that + only native types (bool, int, uint, floats, uintptr and string) + and types which implement error or Stringer interfaces are + supported with other types sorted according to the + reflect.Value.String() output which guarantees display + stability. Natural map order is used by default. + + * SpewKeys + Specifies that, as a last resort attempt, map keys should be + spewed to strings and sorted by those strings. This is only + considered if SortKeys is true. + +Dump Usage + +Simply call spew.Dump with a list of variables you want to dump: + + spew.Dump(myVar1, myVar2, ...) + +You may also call spew.Fdump if you would prefer to output to an arbitrary +io.Writer. For example, to dump to standard error: + + spew.Fdump(os.Stderr, myVar1, myVar2, ...) + +A third option is to call spew.Sdump to get the formatted output as a string: + + str := spew.Sdump(myVar1, myVar2, ...) + +Sample Dump Output + +See the Dump example for details on the setup of the types and variables being +shown here. + + (main.Foo) { + unexportedField: (*main.Bar)(0xf84002e210)({ + flag: (main.Flag) flagTwo, + data: (uintptr) + }), + ExportedField: (map[interface {}]interface {}) (len=1) { + (string) (len=3) "one": (bool) true + } + } + +Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C +command as shown. + ([]uint8) (len=32 cap=32) { + 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... | + 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0| + 00000020 31 32 |12| + } + +Custom Formatter + +Spew provides a custom formatter that implements the fmt.Formatter interface +so that it integrates cleanly with standard fmt package printing functions. The +formatter is useful for inline printing of smaller data types similar to the +standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Custom Formatter Usage + +The simplest way to make use of the spew custom formatter is to call one of the +convenience functions such as spew.Printf, spew.Println, or spew.Printf. The +functions have syntax you are most likely already familiar with: + + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Println(myVar, myVar2) + spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +See the Index for the full list convenience functions. + +Sample Formatter Output + +Double pointer to a uint8: + %v: <**>5 + %+v: <**>(0xf8400420d0->0xf8400420c8)5 + %#v: (**uint8)5 + %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5 + +Pointer to circular struct with a uint8 field and a pointer to itself: + %v: <*>{1 <*>} + %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)} + %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)} + %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)} + +See the Printf example for details on the setup of variables being shown +here. + +Errors + +Since it is possible for custom Stringer/error interfaces to panic, spew +detects them and handles them internally by printing the panic information +inline with the output. Since spew is intended to provide deep pretty printing +capabilities on structures, it intentionally does not return any errors. +*/ +package spew diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go new file mode 100644 index 00000000..df1d582a --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/dump.go @@ -0,0 +1,509 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "encoding/hex" + "fmt" + "io" + "os" + "reflect" + "regexp" + "strconv" + "strings" +) + +var ( + // uint8Type is a reflect.Type representing a uint8. It is used to + // convert cgo types to uint8 slices for hexdumping. + uint8Type = reflect.TypeOf(uint8(0)) + + // cCharRE is a regular expression that matches a cgo char. + // It is used to detect character arrays to hexdump them. + cCharRE = regexp.MustCompile("^.*\\._Ctype_char$") + + // cUnsignedCharRE is a regular expression that matches a cgo unsigned + // char. It is used to detect unsigned character arrays to hexdump + // them. + cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$") + + // cUint8tCharRE is a regular expression that matches a cgo uint8_t. + // It is used to detect uint8_t arrays to hexdump them. + cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$") +) + +// dumpState contains information about the state of a dump operation. +type dumpState struct { + w io.Writer + depth int + pointers map[uintptr]int + ignoreNextType bool + ignoreNextIndent bool + cs *ConfigState +} + +// indent performs indentation according to the depth level and cs.Indent +// option. +func (d *dumpState) indent() { + if d.ignoreNextIndent { + d.ignoreNextIndent = false + return + } + d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth)) +} + +// unpackValue returns values inside of non-nil interfaces when possible. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (d *dumpState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface && !v.IsNil() { + v = v.Elem() + } + return v +} + +// dumpPtr handles formatting of pointers by indirecting them as necessary. +func (d *dumpState) dumpPtr(v reflect.Value) { + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range d.pointers { + if depth >= d.depth { + delete(d.pointers, k) + } + } + + // Keep list of all dereferenced pointers to show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by dereferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := d.pointers[addr]; ok && pd < d.depth { + cycleFound = true + indirects-- + break + } + d.pointers[addr] = d.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type information. + d.w.Write(openParenBytes) + d.w.Write(bytes.Repeat(asteriskBytes, indirects)) + d.w.Write([]byte(ve.Type().String())) + d.w.Write(closeParenBytes) + + // Display pointer information. + if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 { + d.w.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + d.w.Write(pointerChainBytes) + } + printHexPtr(d.w, addr) + } + d.w.Write(closeParenBytes) + } + + // Display dereferenced value. + d.w.Write(openParenBytes) + switch { + case nilFound == true: + d.w.Write(nilAngleBytes) + + case cycleFound == true: + d.w.Write(circularBytes) + + default: + d.ignoreNextType = true + d.dump(ve) + } + d.w.Write(closeParenBytes) +} + +// dumpSlice handles formatting of arrays and slices. Byte (uint8 under +// reflection) arrays and slices are dumped in hexdump -C fashion. +func (d *dumpState) dumpSlice(v reflect.Value) { + // Determine whether this type should be hex dumped or not. Also, + // for types which should be hexdumped, try to use the underlying data + // first, then fall back to trying to convert them to a uint8 slice. + var buf []uint8 + doConvert := false + doHexDump := false + numEntries := v.Len() + if numEntries > 0 { + vt := v.Index(0).Type() + vts := vt.String() + switch { + // C types that need to be converted. + case cCharRE.MatchString(vts): + fallthrough + case cUnsignedCharRE.MatchString(vts): + fallthrough + case cUint8tCharRE.MatchString(vts): + doConvert = true + + // Try to use existing uint8 slices and fall back to converting + // and copying if that fails. + case vt.Kind() == reflect.Uint8: + // We need an addressable interface to convert the type + // to a byte slice. However, the reflect package won't + // give us an interface on certain things like + // unexported struct fields in order to enforce + // visibility rules. We use unsafe, when available, to + // bypass these restrictions since this package does not + // mutate the values. + vs := v + if !vs.CanInterface() || !vs.CanAddr() { + vs = unsafeReflectValue(vs) + } + if !UnsafeDisabled { + vs = vs.Slice(0, numEntries) + + // Use the existing uint8 slice if it can be + // type asserted. + iface := vs.Interface() + if slice, ok := iface.([]uint8); ok { + buf = slice + doHexDump = true + break + } + } + + // The underlying data needs to be converted if it can't + // be type asserted to a uint8 slice. + doConvert = true + } + + // Copy and convert the underlying type if needed. + if doConvert && vt.ConvertibleTo(uint8Type) { + // Convert and copy each element into a uint8 byte + // slice. + buf = make([]uint8, numEntries) + for i := 0; i < numEntries; i++ { + vv := v.Index(i) + buf[i] = uint8(vv.Convert(uint8Type).Uint()) + } + doHexDump = true + } + } + + // Hexdump the entire slice as needed. + if doHexDump { + indent := strings.Repeat(d.cs.Indent, d.depth) + str := indent + hex.Dump(buf) + str = strings.Replace(str, "\n", "\n"+indent, -1) + str = strings.TrimRight(str, d.cs.Indent) + d.w.Write([]byte(str)) + return + } + + // Recursively call dump for each item. + for i := 0; i < numEntries; i++ { + d.dump(d.unpackValue(v.Index(i))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } +} + +// dump is the main workhorse for dumping a value. It uses the passed reflect +// value to figure out what kind of object we are dealing with and formats it +// appropriately. It is a recursive function, however circular data structures +// are detected and handled properly. +func (d *dumpState) dump(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + d.w.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + d.indent() + d.dumpPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !d.ignoreNextType { + d.indent() + d.w.Write(openParenBytes) + d.w.Write([]byte(v.Type().String())) + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + d.ignoreNextType = false + + // Display length and capacity if the built-in len and cap functions + // work with the value's kind and the len/cap itself is non-zero. + valueLen, valueCap := 0, 0 + switch v.Kind() { + case reflect.Array, reflect.Slice, reflect.Chan: + valueLen, valueCap = v.Len(), v.Cap() + case reflect.Map, reflect.String: + valueLen = v.Len() + } + if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 { + d.w.Write(openParenBytes) + if valueLen != 0 { + d.w.Write(lenEqualsBytes) + printInt(d.w, int64(valueLen), 10) + } + if !d.cs.DisableCapacities && valueCap != 0 { + if valueLen != 0 { + d.w.Write(spaceBytes) + } + d.w.Write(capEqualsBytes) + printInt(d.w, int64(valueCap), 10) + } + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + + // Call Stringer/error interfaces if they exist and the handle methods flag + // is enabled + if !d.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(d.cs, d.w, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(d.w, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(d.w, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(d.w, v.Uint(), 10) + + case reflect.Float32: + printFloat(d.w, v.Float(), 32) + + case reflect.Float64: + printFloat(d.w, v.Float(), 64) + + case reflect.Complex64: + printComplex(d.w, v.Complex(), 32) + + case reflect.Complex128: + printComplex(d.w, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + d.dumpSlice(v) + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.String: + d.w.Write([]byte(strconv.Quote(v.String()))) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + d.w.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + numEntries := v.Len() + keys := v.MapKeys() + if d.cs.SortKeys { + sortValues(keys, d.cs) + } + for i, key := range keys { + d.dump(d.unpackValue(key)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.MapIndex(key))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Struct: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + vt := v.Type() + numFields := v.NumField() + for i := 0; i < numFields; i++ { + d.indent() + vtf := vt.Field(i) + d.w.Write([]byte(vtf.Name)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.Field(i))) + if i < (numFields - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(d.w, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(d.w, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it in case any new + // types are added. + default: + if v.CanInterface() { + fmt.Fprintf(d.w, "%v", v.Interface()) + } else { + fmt.Fprintf(d.w, "%v", v.String()) + } + } +} + +// fdump is a helper function to consolidate the logic from the various public +// methods which take varying writers and config states. +func fdump(cs *ConfigState, w io.Writer, a ...interface{}) { + for _, arg := range a { + if arg == nil { + w.Write(interfaceBytes) + w.Write(spaceBytes) + w.Write(nilAngleBytes) + w.Write(newlineBytes) + continue + } + + d := dumpState{w: w, cs: cs} + d.pointers = make(map[uintptr]int) + d.dump(reflect.ValueOf(arg)) + d.w.Write(newlineBytes) + } +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func Fdump(w io.Writer, a ...interface{}) { + fdump(&Config, w, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(&Config, &buf, a...) + return buf.String() +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by an exported package global, +spew.Config. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func Dump(a ...interface{}) { + fdump(&Config, os.Stdout, a...) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go new file mode 100644 index 00000000..c49875ba --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/format.go @@ -0,0 +1,419 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "reflect" + "strconv" + "strings" +) + +// supportedFlags is a list of all the character flags supported by fmt package. +const supportedFlags = "0-+# " + +// formatState implements the fmt.Formatter interface and contains information +// about the state of a formatting operation. The NewFormatter function can +// be used to get a new Formatter which can be used directly as arguments +// in standard fmt package printing calls. +type formatState struct { + value interface{} + fs fmt.State + depth int + pointers map[uintptr]int + ignoreNextType bool + cs *ConfigState +} + +// buildDefaultFormat recreates the original format string without precision +// and width information to pass in to fmt.Sprintf in the case of an +// unrecognized type. Unless new types are added to the language, this +// function won't ever be called. +func (f *formatState) buildDefaultFormat() (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + buf.WriteRune('v') + + format = buf.String() + return format +} + +// constructOrigFormat recreates the original format string including precision +// and width information to pass along to the standard fmt package. This allows +// automatic deferral of all format strings this package doesn't support. +func (f *formatState) constructOrigFormat(verb rune) (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + if width, ok := f.fs.Width(); ok { + buf.WriteString(strconv.Itoa(width)) + } + + if precision, ok := f.fs.Precision(); ok { + buf.Write(precisionBytes) + buf.WriteString(strconv.Itoa(precision)) + } + + buf.WriteRune(verb) + + format = buf.String() + return format +} + +// unpackValue returns values inside of non-nil interfaces when possible and +// ensures that types for values which have been unpacked from an interface +// are displayed when the show types flag is also set. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (f *formatState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface { + f.ignoreNextType = false + if !v.IsNil() { + v = v.Elem() + } + } + return v +} + +// formatPtr handles formatting of pointers by indirecting them as necessary. +func (f *formatState) formatPtr(v reflect.Value) { + // Display nil if top level pointer is nil. + showTypes := f.fs.Flag('#') + if v.IsNil() && (!showTypes || f.ignoreNextType) { + f.fs.Write(nilAngleBytes) + return + } + + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range f.pointers { + if depth >= f.depth { + delete(f.pointers, k) + } + } + + // Keep list of all dereferenced pointers to possibly show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by derferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := f.pointers[addr]; ok && pd < f.depth { + cycleFound = true + indirects-- + break + } + f.pointers[addr] = f.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type or indirection level depending on flags. + if showTypes && !f.ignoreNextType { + f.fs.Write(openParenBytes) + f.fs.Write(bytes.Repeat(asteriskBytes, indirects)) + f.fs.Write([]byte(ve.Type().String())) + f.fs.Write(closeParenBytes) + } else { + if nilFound || cycleFound { + indirects += strings.Count(ve.Type().String(), "*") + } + f.fs.Write(openAngleBytes) + f.fs.Write([]byte(strings.Repeat("*", indirects))) + f.fs.Write(closeAngleBytes) + } + + // Display pointer information depending on flags. + if f.fs.Flag('+') && (len(pointerChain) > 0) { + f.fs.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + f.fs.Write(pointerChainBytes) + } + printHexPtr(f.fs, addr) + } + f.fs.Write(closeParenBytes) + } + + // Display dereferenced value. + switch { + case nilFound == true: + f.fs.Write(nilAngleBytes) + + case cycleFound == true: + f.fs.Write(circularShortBytes) + + default: + f.ignoreNextType = true + f.format(ve) + } +} + +// format is the main workhorse for providing the Formatter interface. It +// uses the passed reflect value to figure out what kind of object we are +// dealing with and formats it appropriately. It is a recursive function, +// however circular data structures are detected and handled properly. +func (f *formatState) format(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + f.fs.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + f.formatPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !f.ignoreNextType && f.fs.Flag('#') { + f.fs.Write(openParenBytes) + f.fs.Write([]byte(v.Type().String())) + f.fs.Write(closeParenBytes) + } + f.ignoreNextType = false + + // Call Stringer/error interfaces if they exist and the handle methods + // flag is enabled. + if !f.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(f.cs, f.fs, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(f.fs, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(f.fs, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(f.fs, v.Uint(), 10) + + case reflect.Float32: + printFloat(f.fs, v.Float(), 32) + + case reflect.Float64: + printFloat(f.fs, v.Float(), 64) + + case reflect.Complex64: + printComplex(f.fs, v.Complex(), 32) + + case reflect.Complex128: + printComplex(f.fs, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + f.fs.Write(openBracketBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + numEntries := v.Len() + for i := 0; i < numEntries; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(v.Index(i))) + } + } + f.depth-- + f.fs.Write(closeBracketBytes) + + case reflect.String: + f.fs.Write([]byte(v.String())) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + f.fs.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + + f.fs.Write(openMapBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + keys := v.MapKeys() + if f.cs.SortKeys { + sortValues(keys, f.cs) + } + for i, key := range keys { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(key)) + f.fs.Write(colonBytes) + f.ignoreNextType = true + f.format(f.unpackValue(v.MapIndex(key))) + } + } + f.depth-- + f.fs.Write(closeMapBytes) + + case reflect.Struct: + numFields := v.NumField() + f.fs.Write(openBraceBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + vt := v.Type() + for i := 0; i < numFields; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + vtf := vt.Field(i) + if f.fs.Flag('+') || f.fs.Flag('#') { + f.fs.Write([]byte(vtf.Name)) + f.fs.Write(colonBytes) + } + f.format(f.unpackValue(v.Field(i))) + } + } + f.depth-- + f.fs.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(f.fs, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(f.fs, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it if any get added. + default: + format := f.buildDefaultFormat() + if v.CanInterface() { + fmt.Fprintf(f.fs, format, v.Interface()) + } else { + fmt.Fprintf(f.fs, format, v.String()) + } + } +} + +// Format satisfies the fmt.Formatter interface. See NewFormatter for usage +// details. +func (f *formatState) Format(fs fmt.State, verb rune) { + f.fs = fs + + // Use standard formatting for verbs that are not v. + if verb != 'v' { + format := f.constructOrigFormat(verb) + fmt.Fprintf(fs, format, f.value) + return + } + + if f.value == nil { + if fs.Flag('#') { + fs.Write(interfaceBytes) + } + fs.Write(nilAngleBytes) + return + } + + f.format(reflect.ValueOf(f.value)) +} + +// newFormatter is a helper function to consolidate the logic from the various +// public methods which take varying config states. +func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter { + fs := &formatState{value: v, cs: cs} + fs.pointers = make(map[uintptr]int) + return fs +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +Printf, Println, or Fprintf. +*/ +func NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(&Config, v) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go new file mode 100644 index 00000000..32c0e338 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/spew.go @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "fmt" + "io" +) + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the formatted string as a value that satisfies error. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a default Formatter interface returned by NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b)) +func Print(a ...interface{}) (n int, err error) { + return fmt.Print(convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b)) +func Println(a ...interface{}) (n int, err error) { + return fmt.Println(convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprint(a ...interface{}) string { + return fmt.Sprint(convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintln(a ...interface{}) string { + return fmt.Sprintln(convertArgs(a)...) +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a default spew Formatter interface. +func convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = NewFormatter(arg) + } + return formatters +} diff --git a/vendor/github.com/golang/protobuf/proto/LICENSE b/vendor/github.com/golang/protobuf/proto/LICENSE new file mode 100644 index 00000000..1b1b1921 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/LICENSE @@ -0,0 +1,31 @@ +Go support for Protocol Buffers - Google's data interchange format + +Copyright 2010 The Go Authors. All rights reserved. +https://github.com/golang/protobuf + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.go new file mode 100644 index 00000000..e392575b --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/clone.go @@ -0,0 +1,229 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Protocol buffer deep copy and merge. +// TODO: RawMessage. + +package proto + +import ( + "log" + "reflect" + "strings" +) + +// Clone returns a deep copy of a protocol buffer. +func Clone(pb Message) Message { + in := reflect.ValueOf(pb) + if in.IsNil() { + return pb + } + + out := reflect.New(in.Type().Elem()) + // out is empty so a merge is a deep copy. + mergeStruct(out.Elem(), in.Elem()) + return out.Interface().(Message) +} + +// Merge merges src into dst. +// Required and optional fields that are set in src will be set to that value in dst. +// Elements of repeated fields will be appended. +// Merge panics if src and dst are not the same type, or if dst is nil. +func Merge(dst, src Message) { + in := reflect.ValueOf(src) + out := reflect.ValueOf(dst) + if out.IsNil() { + panic("proto: nil destination") + } + if in.Type() != out.Type() { + // Explicit test prior to mergeStruct so that mistyped nils will fail + panic("proto: type mismatch") + } + if in.IsNil() { + // Merging nil into non-nil is a quiet no-op + return + } + mergeStruct(out.Elem(), in.Elem()) +} + +func mergeStruct(out, in reflect.Value) { + sprop := GetProperties(in.Type()) + for i := 0; i < in.NumField(); i++ { + f := in.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i]) + } + + if emIn, ok := extendable(in.Addr().Interface()); ok { + emOut, _ := extendable(out.Addr().Interface()) + mIn, muIn := emIn.extensionsRead() + if mIn != nil { + mOut := emOut.extensionsWrite() + muIn.Lock() + mergeExtension(mOut, mIn) + muIn.Unlock() + } + } + + uf := in.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return + } + uin := uf.Bytes() + if len(uin) > 0 { + out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...)) + } +} + +// mergeAny performs a merge between two values of the same type. +// viaPtr indicates whether the values were indirected through a pointer (implying proto2). +// prop is set if this is a struct field (it may be nil). +func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) { + if in.Type() == protoMessageType { + if !in.IsNil() { + if out.IsNil() { + out.Set(reflect.ValueOf(Clone(in.Interface().(Message)))) + } else { + Merge(out.Interface().(Message), in.Interface().(Message)) + } + } + return + } + switch in.Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + if !viaPtr && isProto3Zero(in) { + return + } + out.Set(in) + case reflect.Interface: + // Probably a oneof field; copy non-nil values. + if in.IsNil() { + return + } + // Allocate destination if it is not set, or set to a different type. + // Otherwise we will merge as normal. + if out.IsNil() || out.Elem().Type() != in.Elem().Type() { + out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T) + } + mergeAny(out.Elem(), in.Elem(), false, nil) + case reflect.Map: + if in.Len() == 0 { + return + } + if out.IsNil() { + out.Set(reflect.MakeMap(in.Type())) + } + // For maps with value types of *T or []byte we need to deep copy each value. + elemKind := in.Type().Elem().Kind() + for _, key := range in.MapKeys() { + var val reflect.Value + switch elemKind { + case reflect.Ptr: + val = reflect.New(in.Type().Elem().Elem()) + mergeAny(val, in.MapIndex(key), false, nil) + case reflect.Slice: + val = in.MapIndex(key) + val = reflect.ValueOf(append([]byte{}, val.Bytes()...)) + default: + val = in.MapIndex(key) + } + out.SetMapIndex(key, val) + } + case reflect.Ptr: + if in.IsNil() { + return + } + if out.IsNil() { + out.Set(reflect.New(in.Elem().Type())) + } + mergeAny(out.Elem(), in.Elem(), true, nil) + case reflect.Slice: + if in.IsNil() { + return + } + if in.Type().Elem().Kind() == reflect.Uint8 { + // []byte is a scalar bytes field, not a repeated field. + + // Edge case: if this is in a proto3 message, a zero length + // bytes field is considered the zero value, and should not + // be merged. + if prop != nil && prop.proto3 && in.Len() == 0 { + return + } + + // Make a deep copy. + // Append to []byte{} instead of []byte(nil) so that we never end up + // with a nil result. + out.SetBytes(append([]byte{}, in.Bytes()...)) + return + } + n := in.Len() + if out.IsNil() { + out.Set(reflect.MakeSlice(in.Type(), 0, n)) + } + switch in.Type().Elem().Kind() { + case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, + reflect.String, reflect.Uint32, reflect.Uint64: + out.Set(reflect.AppendSlice(out, in)) + default: + for i := 0; i < n; i++ { + x := reflect.Indirect(reflect.New(in.Type().Elem())) + mergeAny(x, in.Index(i), false, nil) + out.Set(reflect.Append(out, x)) + } + } + case reflect.Struct: + mergeStruct(out, in) + default: + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to copy %v", in) + } +} + +func mergeExtension(out, in map[int32]Extension) { + for extNum, eIn := range in { + eOut := Extension{desc: eIn.desc} + if eIn.value != nil { + v := reflect.New(reflect.TypeOf(eIn.value)).Elem() + mergeAny(v, reflect.ValueOf(eIn.value), false, nil) + eOut.value = v.Interface() + } + if eIn.enc != nil { + eOut.enc = make([]byte, len(eIn.enc)) + copy(eOut.enc, eIn.enc) + } + + out[extNum] = eOut + } +} diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go new file mode 100644 index 00000000..aa207298 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/decode.go @@ -0,0 +1,970 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for decoding protocol buffer data to construct in-memory representations. + */ + +import ( + "errors" + "fmt" + "io" + "os" + "reflect" +) + +// errOverflow is returned when an integer is too large to be represented. +var errOverflow = errors.New("proto: integer overflow") + +// ErrInternalBadWireType is returned by generated code when an incorrect +// wire type is encountered. It does not get returned to user code. +var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") + +// The fundamental decoders that interpret bytes on the wire. +// Those that take integer types all return uint64 and are +// therefore of type valueDecoder. + +// DecodeVarint reads a varint-encoded integer from the slice. +// It returns the integer and the number of bytes consumed, or +// zero if there is not enough. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func DecodeVarint(buf []byte) (x uint64, n int) { + for shift := uint(0); shift < 64; shift += 7 { + if n >= len(buf) { + return 0, 0 + } + b := uint64(buf[n]) + n++ + x |= (b & 0x7F) << shift + if (b & 0x80) == 0 { + return x, n + } + } + + // The number is too large to represent in a 64-bit value. + return 0, 0 +} + +func (p *Buffer) decodeVarintSlow() (x uint64, err error) { + i := p.index + l := len(p.buf) + + for shift := uint(0); shift < 64; shift += 7 { + if i >= l { + err = io.ErrUnexpectedEOF + return + } + b := p.buf[i] + i++ + x |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + p.index = i + return + } + } + + // The number is too large to represent in a 64-bit value. + err = errOverflow + return +} + +// DecodeVarint reads a varint-encoded integer from the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) DecodeVarint() (x uint64, err error) { + i := p.index + buf := p.buf + + if i >= len(buf) { + return 0, io.ErrUnexpectedEOF + } else if buf[i] < 0x80 { + p.index++ + return uint64(buf[i]), nil + } else if len(buf)-i < 10 { + return p.decodeVarintSlow() + } + + var b uint64 + // we already checked the first byte + x = uint64(buf[i]) - 0x80 + i++ + + b = uint64(buf[i]) + i++ + x += b << 7 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 7 + + b = uint64(buf[i]) + i++ + x += b << 14 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 14 + + b = uint64(buf[i]) + i++ + x += b << 21 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 21 + + b = uint64(buf[i]) + i++ + x += b << 28 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 28 + + b = uint64(buf[i]) + i++ + x += b << 35 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 35 + + b = uint64(buf[i]) + i++ + x += b << 42 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 42 + + b = uint64(buf[i]) + i++ + x += b << 49 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 49 + + b = uint64(buf[i]) + i++ + x += b << 56 + if b&0x80 == 0 { + goto done + } + x -= 0x80 << 56 + + b = uint64(buf[i]) + i++ + x += b << 63 + if b&0x80 == 0 { + goto done + } + // x -= 0x80 << 63 // Always zero. + + return 0, errOverflow + +done: + p.index = i + return x, nil +} + +// DecodeFixed64 reads a 64-bit integer from the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) DecodeFixed64() (x uint64, err error) { + // x, err already 0 + i := p.index + 8 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-8]) + x |= uint64(p.buf[i-7]) << 8 + x |= uint64(p.buf[i-6]) << 16 + x |= uint64(p.buf[i-5]) << 24 + x |= uint64(p.buf[i-4]) << 32 + x |= uint64(p.buf[i-3]) << 40 + x |= uint64(p.buf[i-2]) << 48 + x |= uint64(p.buf[i-1]) << 56 + return +} + +// DecodeFixed32 reads a 32-bit integer from the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) DecodeFixed32() (x uint64, err error) { + // x, err already 0 + i := p.index + 4 + if i < 0 || i > len(p.buf) { + err = io.ErrUnexpectedEOF + return + } + p.index = i + + x = uint64(p.buf[i-4]) + x |= uint64(p.buf[i-3]) << 8 + x |= uint64(p.buf[i-2]) << 16 + x |= uint64(p.buf[i-1]) << 24 + return +} + +// DecodeZigzag64 reads a zigzag-encoded 64-bit integer +// from the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) DecodeZigzag64() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63) + return +} + +// DecodeZigzag32 reads a zigzag-encoded 32-bit integer +// from the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) DecodeZigzag32() (x uint64, err error) { + x, err = p.DecodeVarint() + if err != nil { + return + } + x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31)) + return +} + +// These are not ValueDecoders: they produce an array of bytes or a string. +// bytes, embedded messages + +// DecodeRawBytes reads a count-delimited byte buffer from the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { + n, err := p.DecodeVarint() + if err != nil { + return nil, err + } + + nb := int(n) + if nb < 0 { + return nil, fmt.Errorf("proto: bad byte length %d", nb) + } + end := p.index + nb + if end < p.index || end > len(p.buf) { + return nil, io.ErrUnexpectedEOF + } + + if !alloc { + // todo: check if can get more uses of alloc=false + buf = p.buf[p.index:end] + p.index += nb + return + } + + buf = make([]byte, nb) + copy(buf, p.buf[p.index:]) + p.index += nb + return +} + +// DecodeStringBytes reads an encoded string from the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) DecodeStringBytes() (s string, err error) { + buf, err := p.DecodeRawBytes(false) + if err != nil { + return + } + return string(buf), nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +// If the protocol buffer has extensions, and the field matches, add it as an extension. +// Otherwise, if the XXX_unrecognized field exists, append the skipped data there. +func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error { + oi := o.index + + err := o.skip(t, tag, wire) + if err != nil { + return err + } + + if !unrecField.IsValid() { + return nil + } + + ptr := structPointer_Bytes(base, unrecField) + + // Add the skipped field to struct field + obuf := o.buf + + o.buf = *ptr + o.EncodeVarint(uint64(tag<<3 | wire)) + *ptr = append(o.buf, obuf[oi:o.index]...) + + o.buf = obuf + + return nil +} + +// Skip the next item in the buffer. Its wire type is decoded and presented as an argument. +func (o *Buffer) skip(t reflect.Type, tag, wire int) error { + + var u uint64 + var err error + + switch wire { + case WireVarint: + _, err = o.DecodeVarint() + case WireFixed64: + _, err = o.DecodeFixed64() + case WireBytes: + _, err = o.DecodeRawBytes(false) + case WireFixed32: + _, err = o.DecodeFixed32() + case WireStartGroup: + for { + u, err = o.DecodeVarint() + if err != nil { + break + } + fwire := int(u & 0x7) + if fwire == WireEndGroup { + break + } + ftag := int(u >> 3) + err = o.skip(t, ftag, fwire) + if err != nil { + break + } + } + default: + err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t) + } + return err +} + +// Unmarshaler is the interface representing objects that can +// unmarshal themselves. The method should reset the receiver before +// decoding starts. The argument points to data that may be +// overwritten, so implementations should not keep references to the +// buffer. +type Unmarshaler interface { + Unmarshal([]byte) error +} + +// Unmarshal parses the protocol buffer representation in buf and places the +// decoded result in pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// Unmarshal resets pb before starting to unmarshal, so any +// existing data in pb is always removed. Use UnmarshalMerge +// to preserve and append to existing data. +func Unmarshal(buf []byte, pb Message) error { + pb.Reset() + return UnmarshalMerge(buf, pb) +} + +// UnmarshalMerge parses the protocol buffer representation in buf and +// writes the decoded result to pb. If the struct underlying pb does not match +// the data in buf, the results can be unpredictable. +// +// UnmarshalMerge merges into existing data in pb. +// Most code should use Unmarshal instead. +func UnmarshalMerge(buf []byte, pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + return u.Unmarshal(buf) + } + return NewBuffer(buf).Unmarshal(pb) +} + +// DecodeMessage reads a count-delimited message from the Buffer. +func (p *Buffer) DecodeMessage(pb Message) error { + enc, err := p.DecodeRawBytes(false) + if err != nil { + return err + } + return NewBuffer(enc).Unmarshal(pb) +} + +// DecodeGroup reads a tag-delimited group from the Buffer. +func (p *Buffer) DecodeGroup(pb Message) error { + typ, base, err := getbase(pb) + if err != nil { + return err + } + return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base) +} + +// Unmarshal parses the protocol buffer representation in the +// Buffer and places the decoded result in pb. If the struct +// underlying pb does not match the data in the buffer, the results can be +// unpredictable. +// +// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal. +func (p *Buffer) Unmarshal(pb Message) error { + // If the object can unmarshal itself, let it. + if u, ok := pb.(Unmarshaler); ok { + err := u.Unmarshal(p.buf[p.index:]) + p.index = len(p.buf) + return err + } + + typ, base, err := getbase(pb) + if err != nil { + return err + } + + err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base) + + if collectStats { + stats.Decode++ + } + + return err +} + +// unmarshalType does the work of unmarshaling a structure. +func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error { + var state errorState + required, reqFields := prop.reqCount, uint64(0) + + var err error + for err == nil && o.index < len(o.buf) { + oi := o.index + var u uint64 + u, err = o.DecodeVarint() + if err != nil { + break + } + wire := int(u & 0x7) + if wire == WireEndGroup { + if is_group { + if required > 0 { + // Not enough information to determine the exact field. + // (See below.) + return &RequiredNotSetError{"{Unknown}"} + } + return nil // input is satisfied + } + return fmt.Errorf("proto: %s: wiretype end group for non-group", st) + } + tag := int(u >> 3) + if tag <= 0 { + return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire) + } + fieldnum, ok := prop.decoderTags.get(tag) + if !ok { + // Maybe it's an extension? + if prop.extendable { + if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) { + if err = o.skip(st, tag, wire); err == nil { + extmap := e.extensionsWrite() + ext := extmap[int32(tag)] // may be missing + ext.enc = append(ext.enc, o.buf[oi:o.index]...) + extmap[int32(tag)] = ext + } + continue + } + } + // Maybe it's a oneof? + if prop.oneofUnmarshaler != nil { + m := structPointer_Interface(base, st).(Message) + // First return value indicates whether tag is a oneof field. + ok, err = prop.oneofUnmarshaler(m, tag, wire, o) + if err == ErrInternalBadWireType { + // Map the error to something more descriptive. + // Do the formatting here to save generated code space. + err = fmt.Errorf("bad wiretype for oneof field in %T", m) + } + if ok { + continue + } + } + err = o.skipAndSave(st, tag, wire, base, prop.unrecField) + continue + } + p := prop.Prop[fieldnum] + + if p.dec == nil { + fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name) + continue + } + dec := p.dec + if wire != WireStartGroup && wire != p.WireType { + if wire == WireBytes && p.packedDec != nil { + // a packable field + dec = p.packedDec + } else { + err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType) + continue + } + } + decErr := dec(o, p, base) + if decErr != nil && !state.shouldContinue(decErr, p) { + err = decErr + } + if err == nil && p.Required { + // Successfully decoded a required field. + if tag <= 64 { + // use bitmap for fields 1-64 to catch field reuse. + var mask uint64 = 1 << uint64(tag-1) + if reqFields&mask == 0 { + // new required field + reqFields |= mask + required-- + } + } else { + // This is imprecise. It can be fooled by a required field + // with a tag > 64 that is encoded twice; that's very rare. + // A fully correct implementation would require allocating + // a data structure, which we would like to avoid. + required-- + } + } + } + if err == nil { + if is_group { + return io.ErrUnexpectedEOF + } + if state.err != nil { + return state.err + } + if required > 0 { + // Not enough information to determine the exact field. If we use extra + // CPU, we could determine the field only if the missing required field + // has a tag <= 64 and we check reqFields. + return &RequiredNotSetError{"{Unknown}"} + } + } + return err +} + +// Individual type decoders +// For each, +// u is the decoded value, +// v is a pointer to the field (pointer) in the struct + +// Sizes of the pools to allocate inside the Buffer. +// The goal is modest amortization and allocation +// on at least 16-byte boundaries. +const ( + boolPoolSize = 16 + uint32PoolSize = 8 + uint64PoolSize = 4 +) + +// Decode a bool. +func (o *Buffer) dec_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + if len(o.bools) == 0 { + o.bools = make([]bool, boolPoolSize) + } + o.bools[0] = u != 0 + *structPointer_Bool(base, p.field) = &o.bools[0] + o.bools = o.bools[1:] + return nil +} + +func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + *structPointer_BoolVal(base, p.field) = u != 0 + return nil +} + +// Decode an int32. +func (o *Buffer) dec_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32_Set(structPointer_Word32(base, p.field), o, uint32(u)) + return nil +} + +func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u)) + return nil +} + +// Decode an int64. +func (o *Buffer) dec_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64_Set(structPointer_Word64(base, p.field), o, u) + return nil +} + +func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + word64Val_Set(structPointer_Word64Val(base, p.field), o, u) + return nil +} + +// Decode a string. +func (o *Buffer) dec_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_String(base, p.field) = &s + return nil +} + +func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + *structPointer_StringVal(base, p.field) = s + return nil +} + +// Decode a slice of bytes ([]byte). +func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + *structPointer_Bytes(base, p.field) = b + return nil +} + +// Decode a slice of bools ([]bool). +func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + v := structPointer_BoolSlice(base, p.field) + *v = append(*v, u != 0) + return nil +} + +// Decode a slice of bools ([]bool) in packed format. +func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error { + v := structPointer_BoolSlice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded bools + fin := o.index + nb + if fin < o.index { + return errOverflow + } + + y := *v + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + y = append(y, u != 0) + } + + *v = y + return nil +} + +// Decode a slice of int32s ([]int32). +func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + structPointer_Word32Slice(base, p.field).Append(uint32(u)) + return nil +} + +// Decode a slice of int32s ([]int32) in packed format. +func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int32s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(uint32(u)) + } + return nil +} + +// Decode a slice of int64s ([]int64). +func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error { + u, err := p.valDec(o) + if err != nil { + return err + } + + structPointer_Word64Slice(base, p.field).Append(u) + return nil +} + +// Decode a slice of int64s ([]int64) in packed format. +func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Slice(base, p.field) + + nn, err := o.DecodeVarint() + if err != nil { + return err + } + nb := int(nn) // number of bytes of encoded int64s + + fin := o.index + nb + if fin < o.index { + return errOverflow + } + for o.index < fin { + u, err := p.valDec(o) + if err != nil { + return err + } + v.Append(u) + } + return nil +} + +// Decode a slice of strings ([]string). +func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error { + s, err := o.DecodeStringBytes() + if err != nil { + return err + } + v := structPointer_StringSlice(base, p.field) + *v = append(*v, s) + return nil +} + +// Decode a slice of slice of bytes ([][]byte). +func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error { + b, err := o.DecodeRawBytes(true) + if err != nil { + return err + } + v := structPointer_BytesSlice(base, p.field) + *v = append(*v, b) + return nil +} + +// Decode a map field. +func (o *Buffer) dec_new_map(p *Properties, base structPointer) error { + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + oi := o.index // index at the end of this map entry + o.index -= len(raw) // move buffer back to start of map entry + + mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V + if mptr.Elem().IsNil() { + mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem())) + } + v := mptr.Elem() // map[K]V + + // Prepare addressable doubly-indirect placeholders for the key and value types. + // See enc_new_map for why. + keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K + keybase := toStructPointer(keyptr.Addr()) // **K + + var valbase structPointer + var valptr reflect.Value + switch p.mtype.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valptr = reflect.ValueOf(&dummy) // *[]byte + valbase = toStructPointer(valptr) // *[]byte + case reflect.Ptr: + // message; valptr is **Msg; need to allocate the intermediate pointer + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valptr.Set(reflect.New(valptr.Type().Elem())) + valbase = toStructPointer(valptr) + default: + // everything else + valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V + valbase = toStructPointer(valptr.Addr()) // **V + } + + // Decode. + // This parses a restricted wire format, namely the encoding of a message + // with two fields. See enc_new_map for the format. + for o.index < oi { + // tagcode for key and value properties are always a single byte + // because they have tags 1 and 2. + tagcode := o.buf[o.index] + o.index++ + switch tagcode { + case p.mkeyprop.tagcode[0]: + if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil { + return err + } + case p.mvalprop.tagcode[0]: + if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil { + return err + } + default: + // TODO: Should we silently skip this instead? + return fmt.Errorf("proto: bad map data tag %d", raw[0]) + } + } + keyelem, valelem := keyptr.Elem(), valptr.Elem() + if !keyelem.IsValid() { + keyelem = reflect.Zero(p.mtype.Key()) + } + if !valelem.IsValid() { + valelem = reflect.Zero(p.mtype.Elem()) + } + + v.SetMapIndex(keyelem, valelem) + return nil +} + +// Decode a group. +func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error { + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + return o.unmarshalType(p.stype, p.sprop, true, bas) +} + +// Decode an embedded message. +func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) { + raw, e := o.DecodeRawBytes(false) + if e != nil { + return e + } + + bas := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(bas) { + // allocate new nested message + bas = toStructPointer(reflect.New(p.stype)) + structPointer_SetStructPointer(base, p.field, bas) + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := structPointer_Interface(bas, p.stype) + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, false, bas) + o.buf = obuf + o.index = oi + + return err +} + +// Decode a slice of embedded messages. +func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, false, base) +} + +// Decode a slice of embedded groups. +func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error { + return o.dec_slice_struct(p, true, base) +} + +// Decode a slice of structs ([]*struct). +func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error { + v := reflect.New(p.stype) + bas := toStructPointer(v) + structPointer_StructPointerSlice(base, p.field).Append(bas) + + if is_group { + err := o.unmarshalType(p.stype, p.sprop, is_group, bas) + return err + } + + raw, err := o.DecodeRawBytes(false) + if err != nil { + return err + } + + // If the object can unmarshal itself, let it. + if p.isUnmarshaler { + iv := v.Interface() + return iv.(Unmarshaler).Unmarshal(raw) + } + + obuf := o.buf + oi := o.index + o.buf = raw + o.index = 0 + + err = o.unmarshalType(p.stype, p.sprop, is_group, bas) + + o.buf = obuf + o.index = oi + + return err +} diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.go new file mode 100644 index 00000000..2b30f846 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/encode.go @@ -0,0 +1,1362 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "errors" + "fmt" + "reflect" + "sort" +) + +// RequiredNotSetError is the error returned if Marshal is called with +// a protocol buffer struct whose required fields have not +// all been initialized. It is also the error returned if Unmarshal is +// called with an encoded protocol buffer that does not include all the +// required fields. +// +// When printed, RequiredNotSetError reports the first unset required field in a +// message. If the field cannot be precisely determined, it is reported as +// "{Unknown}". +type RequiredNotSetError struct { + field string +} + +func (e *RequiredNotSetError) Error() string { + return fmt.Sprintf("proto: required field %q not set", e.field) +} + +var ( + // errRepeatedHasNil is the error returned if Marshal is called with + // a struct with a repeated field containing a nil element. + errRepeatedHasNil = errors.New("proto: repeated field has nil element") + + // errOneofHasNil is the error returned if Marshal is called with + // a struct with a oneof field containing a nil element. + errOneofHasNil = errors.New("proto: oneof field has nil value") + + // ErrNil is the error returned if Marshal is called with nil. + ErrNil = errors.New("proto: Marshal called with nil") + + // ErrTooLarge is the error returned if Marshal is called with a + // message that encodes to >2GB. + ErrTooLarge = errors.New("proto: message encodes to over 2 GB") +) + +// The fundamental encoders that put bytes on the wire. +// Those that take integer types all accept uint64 and are +// therefore of type valueEncoder. + +const maxVarintBytes = 10 // maximum length of a varint + +// maxMarshalSize is the largest allowed size of an encoded protobuf, +// since C++ and Java use signed int32s for the size. +const maxMarshalSize = 1<<31 - 1 + +// EncodeVarint returns the varint encoding of x. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +// Not used by the package itself, but helpful to clients +// wishing to use the same encoding. +func EncodeVarint(x uint64) []byte { + var buf [maxVarintBytes]byte + var n int + for n = 0; x > 127; n++ { + buf[n] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + buf[n] = uint8(x) + n++ + return buf[0:n] +} + +// EncodeVarint writes a varint-encoded integer to the Buffer. +// This is the format for the +// int32, int64, uint32, uint64, bool, and enum +// protocol buffer types. +func (p *Buffer) EncodeVarint(x uint64) error { + for x >= 1<<7 { + p.buf = append(p.buf, uint8(x&0x7f|0x80)) + x >>= 7 + } + p.buf = append(p.buf, uint8(x)) + return nil +} + +// SizeVarint returns the varint encoding size of an integer. +func SizeVarint(x uint64) int { + return sizeVarint(x) +} + +func sizeVarint(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} + +// EncodeFixed64 writes a 64-bit integer to the Buffer. +// This is the format for the +// fixed64, sfixed64, and double protocol buffer types. +func (p *Buffer) EncodeFixed64(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24), + uint8(x>>32), + uint8(x>>40), + uint8(x>>48), + uint8(x>>56)) + return nil +} + +func sizeFixed64(x uint64) int { + return 8 +} + +// EncodeFixed32 writes a 32-bit integer to the Buffer. +// This is the format for the +// fixed32, sfixed32, and float protocol buffer types. +func (p *Buffer) EncodeFixed32(x uint64) error { + p.buf = append(p.buf, + uint8(x), + uint8(x>>8), + uint8(x>>16), + uint8(x>>24)) + return nil +} + +func sizeFixed32(x uint64) int { + return 4 +} + +// EncodeZigzag64 writes a zigzag-encoded 64-bit integer +// to the Buffer. +// This is the format used for the sint64 protocol buffer type. +func (p *Buffer) EncodeZigzag64(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +func sizeZigzag64(x uint64) int { + return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} + +// EncodeZigzag32 writes a zigzag-encoded 32-bit integer +// to the Buffer. +// This is the format used for the sint32 protocol buffer type. +func (p *Buffer) EncodeZigzag32(x uint64) error { + // use signed number to get arithmetic right shift. + return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +func sizeZigzag32(x uint64) int { + return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) +} + +// EncodeRawBytes writes a count-delimited byte buffer to the Buffer. +// This is the format used for the bytes protocol buffer +// type and for embedded messages. +func (p *Buffer) EncodeRawBytes(b []byte) error { + p.EncodeVarint(uint64(len(b))) + p.buf = append(p.buf, b...) + return nil +} + +func sizeRawBytes(b []byte) int { + return sizeVarint(uint64(len(b))) + + len(b) +} + +// EncodeStringBytes writes an encoded string to the Buffer. +// This is the format used for the proto2 string type. +func (p *Buffer) EncodeStringBytes(s string) error { + p.EncodeVarint(uint64(len(s))) + p.buf = append(p.buf, s...) + return nil +} + +func sizeStringBytes(s string) int { + return sizeVarint(uint64(len(s))) + + len(s) +} + +// Marshaler is the interface representing objects that can marshal themselves. +type Marshaler interface { + Marshal() ([]byte, error) +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, returning the data. +func Marshal(pb Message) ([]byte, error) { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + return m.Marshal() + } + p := NewBuffer(nil) + err := p.Marshal(pb) + if p.buf == nil && err == nil { + // Return a non-nil slice on success. + return []byte{}, nil + } + return p.buf, err +} + +// EncodeMessage writes the protocol buffer to the Buffer, +// prefixed by a varint-encoded length. +func (p *Buffer) EncodeMessage(pb Message) error { + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + var state errorState + err = p.enc_len_struct(GetProperties(t.Elem()), base, &state) + } + return err +} + +// Marshal takes the protocol buffer +// and encodes it into the wire format, writing the result to the +// Buffer. +func (p *Buffer) Marshal(pb Message) error { + // Can the object marshal itself? + if m, ok := pb.(Marshaler); ok { + data, err := m.Marshal() + p.buf = append(p.buf, data...) + return err + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return ErrNil + } + if err == nil { + err = p.enc_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + (stats).Encode++ // Parens are to work around a goimports bug. + } + + if len(p.buf) > maxMarshalSize { + return ErrTooLarge + } + return err +} + +// Size returns the encoded size of a protocol buffer. +func Size(pb Message) (n int) { + // Can the object marshal itself? If so, Size is slow. + // TODO: add Size to Marshaler, or add a Sizer interface. + if m, ok := pb.(Marshaler); ok { + b, _ := m.Marshal() + return len(b) + } + + t, base, err := getbase(pb) + if structPointer_IsNil(base) { + return 0 + } + if err == nil { + n = size_struct(GetProperties(t.Elem()), base) + } + + if collectStats { + (stats).Size++ // Parens are to work around a goimports bug. + } + + return +} + +// Individual type encoders. + +// Encode a bool. +func (o *Buffer) enc_bool(p *Properties, base structPointer) error { + v := *structPointer_Bool(base, p.field) + if v == nil { + return ErrNil + } + x := 0 + if *v { + x = 1 + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error { + v := *structPointer_BoolVal(base, p.field) + if !v { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, 1) + return nil +} + +func size_bool(p *Properties, base structPointer) int { + v := *structPointer_Bool(base, p.field) + if v == nil { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +func size_proto3_bool(p *Properties, base structPointer) int { + v := *structPointer_BoolVal(base, p.field) + if !v && !p.oneof { + return 0 + } + return len(p.tagcode) + 1 // each bool takes exactly one byte +} + +// Encode an int32. +func (o *Buffer) enc_int32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_int32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode a uint32. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return ErrNil + } + x := word32_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, uint64(x)) + return nil +} + +func size_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32(base, p.field) + if word32_IsNil(v) { + return 0 + } + x := word32_Get(v) + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +func size_proto3_uint32(p *Properties, base structPointer) (n int) { + v := structPointer_Word32Val(base, p.field) + x := word32Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(uint64(x)) + return +} + +// Encode an int64. +func (o *Buffer) enc_int64(p *Properties, base structPointer) error { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return ErrNil + } + x := word64_Get(v) + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, x) + return nil +} + +func size_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64(base, p.field) + if word64_IsNil(v) { + return 0 + } + x := word64_Get(v) + n += len(p.tagcode) + n += p.valSize(x) + return +} + +func size_proto3_int64(p *Properties, base structPointer) (n int) { + v := structPointer_Word64Val(base, p.field) + x := word64Val_Get(v) + if x == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += p.valSize(x) + return +} + +// Encode a string. +func (o *Buffer) enc_string(p *Properties, base structPointer) error { + v := *structPointer_String(base, p.field) + if v == nil { + return ErrNil + } + x := *v + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(x) + return nil +} + +func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error { + v := *structPointer_StringVal(base, p.field) + if v == "" { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(v) + return nil +} + +func size_string(p *Properties, base structPointer) (n int) { + v := *structPointer_String(base, p.field) + if v == nil { + return 0 + } + x := *v + n += len(p.tagcode) + n += sizeStringBytes(x) + return +} + +func size_proto3_string(p *Properties, base structPointer) (n int) { + v := *structPointer_StringVal(base, p.field) + if v == "" && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeStringBytes(v) + return +} + +// All protocol buffer fields are nillable, but be careful. +func isNil(v reflect.Value) bool { + switch v.Kind() { + case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + return v.IsNil() + } + return false +} + +// Encode a message struct. +func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error { + var state errorState + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return ErrNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + return state.err + } + + o.buf = append(o.buf, p.tagcode...) + return o.enc_len_struct(p.sprop, structp, &state) +} + +func size_struct_message(p *Properties, base structPointer) int { + structp := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(structp) { + return 0 + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n0 := len(p.tagcode) + n1 := sizeRawBytes(data) + return n0 + n1 + } + + n0 := len(p.tagcode) + n1 := size_struct(p.sprop, structp) + n2 := sizeVarint(uint64(n1)) // size of encoded length + return n0 + n1 + n2 +} + +// Encode a group struct. +func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error { + var state errorState + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return ErrNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + err := o.enc_struct(p.sprop, b) + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return state.err +} + +func size_struct_group(p *Properties, base structPointer) (n int) { + b := structPointer_GetStructPointer(base, p.field) + if structPointer_IsNil(b) { + return 0 + } + + n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup)) + n += size_struct(p.sprop, b) + n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup)) + return +} + +// Encode a slice of bools ([]bool). +func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + for _, x := range s { + o.buf = append(o.buf, p.tagcode...) + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_bool(p *Properties, base structPointer) int { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + return l * (len(p.tagcode) + 1) // each bool takes exactly one byte +} + +// Encode a slice of bools ([]bool) in packed format. +func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(l)) // each bool takes exactly one byte + for _, x := range s { + v := uint64(0) + if x { + v = 1 + } + p.valEnc(o, v) + } + return nil +} + +func size_slice_packed_bool(p *Properties, base structPointer) (n int) { + s := *structPointer_BoolSlice(base, p.field) + l := len(s) + if l == 0 { + return 0 + } + n += len(p.tagcode) + n += sizeVarint(uint64(l)) + n += l // each bool takes exactly one byte + return +} + +// Encode a slice of bytes ([]byte). +func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if s == nil { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 { + return ErrNil + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(s) + return nil +} + +func size_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if s == nil && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +func size_proto3_slice_byte(p *Properties, base structPointer) (n int) { + s := *structPointer_Bytes(base, p.field) + if len(s) == 0 && !p.oneof { + return 0 + } + n += len(p.tagcode) + n += sizeRawBytes(s) + return +} + +// Encode a slice of int32s ([]int32). +func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of int32s ([]int32) in packed format. +func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + p.valEnc(buf, uint64(x)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + x := int32(s.Index(i)) // permit sign extension to use full 64-bit range + bufSize += p.valSize(uint64(x)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of uint32s ([]uint32). +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + x := s.Index(i) + p.valEnc(o, uint64(x)) + } + return nil +} + +func size_slice_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + x := s.Index(i) + n += p.valSize(uint64(x)) + } + return +} + +// Encode a slice of uint32s ([]uint32) in packed format. +// Exactly the same as int32, except for no sign extension. +func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, uint64(s.Index(i))) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_uint32(p *Properties, base structPointer) (n int) { + s := structPointer_Word32Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(uint64(s.Index(i))) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of int64s ([]int64). +func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + p.valEnc(o, s.Index(i)) + } + return nil +} + +func size_slice_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + for i := 0; i < l; i++ { + n += len(p.tagcode) + n += p.valSize(s.Index(i)) + } + return +} + +// Encode a slice of int64s ([]int64) in packed format. +func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return ErrNil + } + // TODO: Reuse a Buffer. + buf := NewBuffer(nil) + for i := 0; i < l; i++ { + p.valEnc(buf, s.Index(i)) + } + + o.buf = append(o.buf, p.tagcode...) + o.EncodeVarint(uint64(len(buf.buf))) + o.buf = append(o.buf, buf.buf...) + return nil +} + +func size_slice_packed_int64(p *Properties, base structPointer) (n int) { + s := structPointer_Word64Slice(base, p.field) + l := s.Len() + if l == 0 { + return 0 + } + var bufSize int + for i := 0; i < l; i++ { + bufSize += p.valSize(s.Index(i)) + } + + n += len(p.tagcode) + n += sizeVarint(uint64(bufSize)) + n += bufSize + return +} + +// Encode a slice of slice of bytes ([][]byte). +func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return ErrNil + } + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(ss[i]) + } + return nil +} + +func size_slice_slice_byte(p *Properties, base structPointer) (n int) { + ss := *structPointer_BytesSlice(base, p.field) + l := len(ss) + if l == 0 { + return 0 + } + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeRawBytes(ss[i]) + } + return +} + +// Encode a slice of strings ([]string). +func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + for i := 0; i < l; i++ { + o.buf = append(o.buf, p.tagcode...) + o.EncodeStringBytes(ss[i]) + } + return nil +} + +func size_slice_string(p *Properties, base structPointer) (n int) { + ss := *structPointer_StringSlice(base, p.field) + l := len(ss) + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + n += sizeStringBytes(ss[i]) + } + return +} + +// Encode a slice of message structs ([]*struct). +func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return errRepeatedHasNil + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, err := m.Marshal() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + o.buf = append(o.buf, p.tagcode...) + o.EncodeRawBytes(data) + continue + } + + o.buf = append(o.buf, p.tagcode...) + err := o.enc_len_struct(p.sprop, structp, &state) + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + } + return state.err +} + +func size_slice_struct_message(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + n += l * len(p.tagcode) + for i := 0; i < l; i++ { + structp := s.Index(i) + if structPointer_IsNil(structp) { + return // return the size up to this point + } + + // Can the object marshal itself? + if p.isMarshaler { + m := structPointer_Interface(structp, p.stype).(Marshaler) + data, _ := m.Marshal() + n += sizeRawBytes(data) + continue + } + + n0 := size_struct(p.sprop, structp) + n1 := sizeVarint(uint64(n0)) // size of encoded length + n += n0 + n1 + } + return +} + +// Encode a slice of group structs ([]*struct). +func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error { + var state errorState + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return errRepeatedHasNil + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) + + err := o.enc_struct(p.sprop, b) + + if err != nil && !state.shouldContinue(err, nil) { + if err == ErrNil { + return errRepeatedHasNil + } + return err + } + + o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) + } + return state.err +} + +func size_slice_struct_group(p *Properties, base structPointer) (n int) { + s := structPointer_StructPointerSlice(base, p.field) + l := s.Len() + + n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup)) + n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup)) + for i := 0; i < l; i++ { + b := s.Index(i) + if structPointer_IsNil(b) { + return // return size up to this point + } + + n += size_struct(p.sprop, b) + } + return +} + +// Encode an extension map. +func (o *Buffer) enc_map(p *Properties, base structPointer) error { + exts := structPointer_ExtMap(base, p.field) + if err := encodeExtensionsMap(*exts); err != nil { + return err + } + + return o.enc_map_body(*exts) +} + +func (o *Buffer) enc_exts(p *Properties, base structPointer) error { + exts := structPointer_Extensions(base, p.field) + + v, mu := exts.extensionsRead() + if v == nil { + return nil + } + + mu.Lock() + defer mu.Unlock() + if err := encodeExtensionsMap(v); err != nil { + return err + } + + return o.enc_map_body(v) +} + +func (o *Buffer) enc_map_body(v map[int32]Extension) error { + // Fast-path for common cases: zero or one extensions. + if len(v) <= 1 { + for _, e := range v { + o.buf = append(o.buf, e.enc...) + } + return nil + } + + // Sort keys to provide a deterministic encoding. + keys := make([]int, 0, len(v)) + for k := range v { + keys = append(keys, int(k)) + } + sort.Ints(keys) + + for _, k := range keys { + o.buf = append(o.buf, v[int32(k)].enc...) + } + return nil +} + +func size_map(p *Properties, base structPointer) int { + v := structPointer_ExtMap(base, p.field) + return extensionsMapSize(*v) +} + +func size_exts(p *Properties, base structPointer) int { + v := structPointer_Extensions(base, p.field) + return extensionsSize(v) +} + +// Encode a map field. +func (o *Buffer) enc_new_map(p *Properties, base structPointer) error { + var state errorState // XXX: or do we need to plumb this through? + + /* + A map defined as + map map_field = N; + is encoded in the same way as + message MapFieldEntry { + key_type key = 1; + value_type value = 2; + } + repeated MapFieldEntry map_field = N; + */ + + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + if v.Len() == 0 { + return nil + } + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + enc := func() error { + if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil { + return err + } + if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil { + return err + } + return nil + } + + // Don't sort map keys. It is not required by the spec, and C++ doesn't do it. + for _, key := range v.MapKeys() { + val := v.MapIndex(key) + + keycopy.Set(key) + valcopy.Set(val) + + o.buf = append(o.buf, p.tagcode...) + if err := o.enc_len_thing(enc, &state); err != nil { + return err + } + } + return nil +} + +func size_new_map(p *Properties, base structPointer) int { + v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V + + keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype) + + n := 0 + for _, key := range v.MapKeys() { + val := v.MapIndex(key) + keycopy.Set(key) + valcopy.Set(val) + + // Tag codes for key and val are the responsibility of the sub-sizer. + keysize := p.mkeyprop.size(p.mkeyprop, keybase) + valsize := p.mvalprop.size(p.mvalprop, valbase) + entry := keysize + valsize + // Add on tag code and length of map entry itself. + n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry + } + return n +} + +// mapEncodeScratch returns a new reflect.Value matching the map's value type, +// and a structPointer suitable for passing to an encoder or sizer. +func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) { + // Prepare addressable doubly-indirect placeholders for the key and value types. + // This is needed because the element-type encoders expect **T, but the map iteration produces T. + + keycopy = reflect.New(mapType.Key()).Elem() // addressable K + keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K + keyptr.Set(keycopy.Addr()) // + keybase = toStructPointer(keyptr.Addr()) // **K + + // Value types are more varied and require special handling. + switch mapType.Elem().Kind() { + case reflect.Slice: + // []byte + var dummy []byte + valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte + valbase = toStructPointer(valcopy.Addr()) + case reflect.Ptr: + // message; the generated field type is map[K]*Msg (so V is *Msg), + // so we only need one level of indirection. + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valbase = toStructPointer(valcopy.Addr()) + default: + // everything else + valcopy = reflect.New(mapType.Elem()).Elem() // addressable V + valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V + valptr.Set(valcopy.Addr()) // + valbase = toStructPointer(valptr.Addr()) // **V + } + return +} + +// Encode a struct. +func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error { + var state errorState + // Encode fields in tag order so that decoders may use optimizations + // that depend on the ordering. + // https://developers.google.com/protocol-buffers/docs/encoding#order + for _, i := range prop.order { + p := prop.Prop[i] + if p.enc != nil { + err := p.enc(o, p, base) + if err != nil { + if err == ErrNil { + if p.Required && state.err == nil { + state.err = &RequiredNotSetError{p.Name} + } + } else if err == errRepeatedHasNil { + // Give more context to nil values in repeated fields. + return errors.New("repeated field " + p.OrigName + " has nil element") + } else if !state.shouldContinue(err, p) { + return err + } + } + if len(o.buf) > maxMarshalSize { + return ErrTooLarge + } + } + } + + // Do oneof fields. + if prop.oneofMarshaler != nil { + m := structPointer_Interface(base, prop.stype).(Message) + if err := prop.oneofMarshaler(m, o); err == ErrNil { + return errOneofHasNil + } else if err != nil { + return err + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + if len(o.buf)+len(v) > maxMarshalSize { + return ErrTooLarge + } + if len(v) > 0 { + o.buf = append(o.buf, v...) + } + } + + return state.err +} + +func size_struct(prop *StructProperties, base structPointer) (n int) { + for _, i := range prop.order { + p := prop.Prop[i] + if p.size != nil { + n += p.size(p, base) + } + } + + // Add unrecognized fields at the end. + if prop.unrecField.IsValid() { + v := *structPointer_Bytes(base, prop.unrecField) + n += len(v) + } + + // Factor in any oneof fields. + if prop.oneofSizer != nil { + m := structPointer_Interface(base, prop.stype).(Message) + n += prop.oneofSizer(m) + } + + return +} + +var zeroes [20]byte // longer than any conceivable sizeVarint + +// Encode a struct, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error { + return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state) +} + +// Encode something, preceded by its encoded length (as a varint). +func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error { + iLen := len(o.buf) + o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length + iMsg := len(o.buf) + err := enc() + if err != nil && !state.shouldContinue(err, nil) { + return err + } + lMsg := len(o.buf) - iMsg + lLen := sizeVarint(uint64(lMsg)) + switch x := lLen - (iMsg - iLen); { + case x > 0: // actual length is x bytes larger than the space we reserved + // Move msg x bytes right. + o.buf = append(o.buf, zeroes[:x]...) + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + case x < 0: // actual length is x bytes smaller than the space we reserved + // Move msg x bytes left. + copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg]) + o.buf = o.buf[:len(o.buf)+x] // x is negative + } + // Encode the length in the reserved space. + o.buf = o.buf[:iLen] + o.EncodeVarint(uint64(lMsg)) + o.buf = o.buf[:len(o.buf)+lMsg] + return state.err +} + +// errorState maintains the first error that occurs and updates that error +// with additional context. +type errorState struct { + err error +} + +// shouldContinue reports whether encoding should continue upon encountering the +// given error. If the error is RequiredNotSetError, shouldContinue returns true +// and, if this is the first appearance of that error, remembers it for future +// reporting. +// +// If prop is not nil, it may update any error with additional context about the +// field with the error. +func (s *errorState) shouldContinue(err error, prop *Properties) bool { + // Ignore unset required fields. + reqNotSet, ok := err.(*RequiredNotSetError) + if !ok { + return false + } + if s.err == nil { + if prop != nil { + err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field} + } + s.err = err + } + return true +} diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go new file mode 100644 index 00000000..2ed1cf59 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/equal.go @@ -0,0 +1,300 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2011 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Protocol buffer comparison. + +package proto + +import ( + "bytes" + "log" + "reflect" + "strings" +) + +/* +Equal returns true iff protocol buffers a and b are equal. +The arguments must both be pointers to protocol buffer structs. + +Equality is defined in this way: + - Two messages are equal iff they are the same type, + corresponding fields are equal, unknown field sets + are equal, and extensions sets are equal. + - Two set scalar fields are equal iff their values are equal. + If the fields are of a floating-point type, remember that + NaN != x for all x, including NaN. If the message is defined + in a proto3 .proto file, fields are not "set"; specifically, + zero length proto3 "bytes" fields are equal (nil == {}). + - Two repeated fields are equal iff their lengths are the same, + and their corresponding elements are equal. Note a "bytes" field, + although represented by []byte, is not a repeated field and the + rule for the scalar fields described above applies. + - Two unset fields are equal. + - Two unknown field sets are equal if their current + encoded state is equal. + - Two extension sets are equal iff they have corresponding + elements that are pairwise equal. + - Two map fields are equal iff their lengths are the same, + and they contain the same set of elements. Zero-length map + fields are equal. + - Every other combination of things are not equal. + +The return value is undefined if a and b are not protocol buffers. +*/ +func Equal(a, b Message) bool { + if a == nil || b == nil { + return a == b + } + v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b) + if v1.Type() != v2.Type() { + return false + } + if v1.Kind() == reflect.Ptr { + if v1.IsNil() { + return v2.IsNil() + } + if v2.IsNil() { + return false + } + v1, v2 = v1.Elem(), v2.Elem() + } + if v1.Kind() != reflect.Struct { + return false + } + return equalStruct(v1, v2) +} + +// v1 and v2 are known to have the same type. +func equalStruct(v1, v2 reflect.Value) bool { + sprop := GetProperties(v1.Type()) + for i := 0; i < v1.NumField(); i++ { + f := v1.Type().Field(i) + if strings.HasPrefix(f.Name, "XXX_") { + continue + } + f1, f2 := v1.Field(i), v2.Field(i) + if f.Type.Kind() == reflect.Ptr { + if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 { + // both unset + continue + } else if n1 != n2 { + // set/unset mismatch + return false + } + b1, ok := f1.Interface().(raw) + if ok { + b2 := f2.Interface().(raw) + // RawMessage + if !bytes.Equal(b1.Bytes(), b2.Bytes()) { + return false + } + continue + } + f1, f2 = f1.Elem(), f2.Elem() + } + if !equalAny(f1, f2, sprop.Prop[i]) { + return false + } + } + + if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_InternalExtensions") + if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) { + return false + } + } + + if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() { + em2 := v2.FieldByName("XXX_extensions") + if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) { + return false + } + } + + uf := v1.FieldByName("XXX_unrecognized") + if !uf.IsValid() { + return true + } + + u1 := uf.Bytes() + u2 := v2.FieldByName("XXX_unrecognized").Bytes() + if !bytes.Equal(u1, u2) { + return false + } + + return true +} + +// v1 and v2 are known to have the same type. +// prop may be nil. +func equalAny(v1, v2 reflect.Value, prop *Properties) bool { + if v1.Type() == protoMessageType { + m1, _ := v1.Interface().(Message) + m2, _ := v2.Interface().(Message) + return Equal(m1, m2) + } + switch v1.Kind() { + case reflect.Bool: + return v1.Bool() == v2.Bool() + case reflect.Float32, reflect.Float64: + return v1.Float() == v2.Float() + case reflect.Int32, reflect.Int64: + return v1.Int() == v2.Int() + case reflect.Interface: + // Probably a oneof field; compare the inner values. + n1, n2 := v1.IsNil(), v2.IsNil() + if n1 || n2 { + return n1 == n2 + } + e1, e2 := v1.Elem(), v2.Elem() + if e1.Type() != e2.Type() { + return false + } + return equalAny(e1, e2, nil) + case reflect.Map: + if v1.Len() != v2.Len() { + return false + } + for _, key := range v1.MapKeys() { + val2 := v2.MapIndex(key) + if !val2.IsValid() { + // This key was not found in the second map. + return false + } + if !equalAny(v1.MapIndex(key), val2, nil) { + return false + } + } + return true + case reflect.Ptr: + // Maps may have nil values in them, so check for nil. + if v1.IsNil() && v2.IsNil() { + return true + } + if v1.IsNil() != v2.IsNil() { + return false + } + return equalAny(v1.Elem(), v2.Elem(), prop) + case reflect.Slice: + if v1.Type().Elem().Kind() == reflect.Uint8 { + // short circuit: []byte + + // Edge case: if this is in a proto3 message, a zero length + // bytes field is considered the zero value. + if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 { + return true + } + if v1.IsNil() != v2.IsNil() { + return false + } + return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte)) + } + + if v1.Len() != v2.Len() { + return false + } + for i := 0; i < v1.Len(); i++ { + if !equalAny(v1.Index(i), v2.Index(i), prop) { + return false + } + } + return true + case reflect.String: + return v1.Interface().(string) == v2.Interface().(string) + case reflect.Struct: + return equalStruct(v1, v2) + case reflect.Uint32, reflect.Uint64: + return v1.Uint() == v2.Uint() + } + + // unknown type, so not a protocol buffer + log.Printf("proto: don't know how to compare %v", v1) + return false +} + +// base is the struct type that the extensions are based on. +// x1 and x2 are InternalExtensions. +func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool { + em1, _ := x1.extensionsRead() + em2, _ := x2.extensionsRead() + return equalExtMap(base, em1, em2) +} + +func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool { + if len(em1) != len(em2) { + return false + } + + for extNum, e1 := range em1 { + e2, ok := em2[extNum] + if !ok { + return false + } + + m1, m2 := e1.value, e2.value + + if m1 != nil && m2 != nil { + // Both are unencoded. + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + continue + } + + // At least one is encoded. To do a semantically correct comparison + // we need to unmarshal them first. + var desc *ExtensionDesc + if m := extensionMaps[base]; m != nil { + desc = m[extNum] + } + if desc == nil { + log.Printf("proto: don't know how to compare extension %d of %v", extNum, base) + continue + } + var err error + if m1 == nil { + m1, err = decodeExtension(e1.enc, desc) + } + if m2 == nil && err == nil { + m2, err = decodeExtension(e2.enc, desc) + } + if err != nil { + // The encoded form is invalid. + log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err) + return false + } + if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { + return false + } + } + + return true +} diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go new file mode 100644 index 00000000..eaad2183 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/extensions.go @@ -0,0 +1,587 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Types and routines for supporting protocol buffer extensions. + */ + +import ( + "errors" + "fmt" + "reflect" + "strconv" + "sync" +) + +// ErrMissingExtension is the error returned by GetExtension if the named extension is not in the message. +var ErrMissingExtension = errors.New("proto: missing extension") + +// ExtensionRange represents a range of message extensions for a protocol buffer. +// Used in code generated by the protocol compiler. +type ExtensionRange struct { + Start, End int32 // both inclusive +} + +// extendableProto is an interface implemented by any protocol buffer generated by the current +// proto compiler that may be extended. +type extendableProto interface { + Message + ExtensionRangeArray() []ExtensionRange + extensionsWrite() map[int32]Extension + extensionsRead() (map[int32]Extension, sync.Locker) +} + +// extendableProtoV1 is an interface implemented by a protocol buffer generated by the previous +// version of the proto compiler that may be extended. +type extendableProtoV1 interface { + Message + ExtensionRangeArray() []ExtensionRange + ExtensionMap() map[int32]Extension +} + +// extensionAdapter is a wrapper around extendableProtoV1 that implements extendableProto. +type extensionAdapter struct { + extendableProtoV1 +} + +func (e extensionAdapter) extensionsWrite() map[int32]Extension { + return e.ExtensionMap() +} + +func (e extensionAdapter) extensionsRead() (map[int32]Extension, sync.Locker) { + return e.ExtensionMap(), notLocker{} +} + +// notLocker is a sync.Locker whose Lock and Unlock methods are nops. +type notLocker struct{} + +func (n notLocker) Lock() {} +func (n notLocker) Unlock() {} + +// extendable returns the extendableProto interface for the given generated proto message. +// If the proto message has the old extension format, it returns a wrapper that implements +// the extendableProto interface. +func extendable(p interface{}) (extendableProto, bool) { + if ep, ok := p.(extendableProto); ok { + return ep, ok + } + if ep, ok := p.(extendableProtoV1); ok { + return extensionAdapter{ep}, ok + } + return nil, false +} + +// XXX_InternalExtensions is an internal representation of proto extensions. +// +// Each generated message struct type embeds an anonymous XXX_InternalExtensions field, +// thus gaining the unexported 'extensions' method, which can be called only from the proto package. +// +// The methods of XXX_InternalExtensions are not concurrency safe in general, +// but calls to logically read-only methods such as has and get may be executed concurrently. +type XXX_InternalExtensions struct { + // The struct must be indirect so that if a user inadvertently copies a + // generated message and its embedded XXX_InternalExtensions, they + // avoid the mayhem of a copied mutex. + // + // The mutex serializes all logically read-only operations to p.extensionMap. + // It is up to the client to ensure that write operations to p.extensionMap are + // mutually exclusive with other accesses. + p *struct { + mu sync.Mutex + extensionMap map[int32]Extension + } +} + +// extensionsWrite returns the extension map, creating it on first use. +func (e *XXX_InternalExtensions) extensionsWrite() map[int32]Extension { + if e.p == nil { + e.p = new(struct { + mu sync.Mutex + extensionMap map[int32]Extension + }) + e.p.extensionMap = make(map[int32]Extension) + } + return e.p.extensionMap +} + +// extensionsRead returns the extensions map for read-only use. It may be nil. +// The caller must hold the returned mutex's lock when accessing Elements within the map. +func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locker) { + if e.p == nil { + return nil, nil + } + return e.p.extensionMap, &e.p.mu +} + +var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem() +var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem() + +// ExtensionDesc represents an extension specification. +// Used in generated code from the protocol compiler. +type ExtensionDesc struct { + ExtendedType Message // nil pointer to the type that is being extended + ExtensionType interface{} // nil pointer to the extension type + Field int32 // field number + Name string // fully-qualified name of extension, for text formatting + Tag string // protobuf tag style + Filename string // name of the file in which the extension is defined +} + +func (ed *ExtensionDesc) repeated() bool { + t := reflect.TypeOf(ed.ExtensionType) + return t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 +} + +// Extension represents an extension in a message. +type Extension struct { + // When an extension is stored in a message using SetExtension + // only desc and value are set. When the message is marshaled + // enc will be set to the encoded form of the message. + // + // When a message is unmarshaled and contains extensions, each + // extension will have only enc set. When such an extension is + // accessed using GetExtension (or GetExtensions) desc and value + // will be set. + desc *ExtensionDesc + value interface{} + enc []byte +} + +// SetRawExtension is for testing only. +func SetRawExtension(base Message, id int32, b []byte) { + epb, ok := extendable(base) + if !ok { + return + } + extmap := epb.extensionsWrite() + extmap[id] = Extension{enc: b} +} + +// isExtensionField returns true iff the given field number is in an extension range. +func isExtensionField(pb extendableProto, field int32) bool { + for _, er := range pb.ExtensionRangeArray() { + if er.Start <= field && field <= er.End { + return true + } + } + return false +} + +// checkExtensionTypes checks that the given extension is valid for pb. +func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error { + var pbi interface{} = pb + // Check the extended type. + if ea, ok := pbi.(extensionAdapter); ok { + pbi = ea.extendableProtoV1 + } + if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b { + return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String()) + } + // Check the range. + if !isExtensionField(pb, extension.Field) { + return errors.New("proto: bad extension number; not in declared ranges") + } + return nil +} + +// extPropKey is sufficient to uniquely identify an extension. +type extPropKey struct { + base reflect.Type + field int32 +} + +var extProp = struct { + sync.RWMutex + m map[extPropKey]*Properties +}{ + m: make(map[extPropKey]*Properties), +} + +func extensionProperties(ed *ExtensionDesc) *Properties { + key := extPropKey{base: reflect.TypeOf(ed.ExtendedType), field: ed.Field} + + extProp.RLock() + if prop, ok := extProp.m[key]; ok { + extProp.RUnlock() + return prop + } + extProp.RUnlock() + + extProp.Lock() + defer extProp.Unlock() + // Check again. + if prop, ok := extProp.m[key]; ok { + return prop + } + + prop := new(Properties) + prop.Init(reflect.TypeOf(ed.ExtensionType), "unknown_name", ed.Tag, nil) + extProp.m[key] = prop + return prop +} + +// encode encodes any unmarshaled (unencoded) extensions in e. +func encodeExtensions(e *XXX_InternalExtensions) error { + m, mu := e.extensionsRead() + if m == nil { + return nil // fast path + } + mu.Lock() + defer mu.Unlock() + return encodeExtensionsMap(m) +} + +// encode encodes any unmarshaled (unencoded) extensions in e. +func encodeExtensionsMap(m map[int32]Extension) error { + for k, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + continue + } + + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + p := NewBuffer(nil) + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + if err := props.enc(p, props, toStructPointer(x)); err != nil { + return err + } + e.enc = p.buf + m[k] = e + } + return nil +} + +func extensionsSize(e *XXX_InternalExtensions) (n int) { + m, mu := e.extensionsRead() + if m == nil { + return 0 + } + mu.Lock() + defer mu.Unlock() + return extensionsMapSize(m) +} + +func extensionsMapSize(m map[int32]Extension) (n int) { + for _, e := range m { + if e.value == nil || e.desc == nil { + // Extension is only in its encoded form. + n += len(e.enc) + continue + } + + // We don't skip extensions that have an encoded form set, + // because the extension value may have been mutated after + // the last time this function was called. + + et := reflect.TypeOf(e.desc.ExtensionType) + props := extensionProperties(e.desc) + + // If e.value has type T, the encoder expects a *struct{ X T }. + // Pass a *T with a zero field and hope it all works out. + x := reflect.New(et) + x.Elem().Set(reflect.ValueOf(e.value)) + n += props.size(props, toStructPointer(x)) + } + return +} + +// HasExtension returns whether the given extension is present in pb. +func HasExtension(pb Message, extension *ExtensionDesc) bool { + // TODO: Check types, field numbers, etc.? + epb, ok := extendable(pb) + if !ok { + return false + } + extmap, mu := epb.extensionsRead() + if extmap == nil { + return false + } + mu.Lock() + _, ok = extmap[extension.Field] + mu.Unlock() + return ok +} + +// ClearExtension removes the given extension from pb. +func ClearExtension(pb Message, extension *ExtensionDesc) { + epb, ok := extendable(pb) + if !ok { + return + } + // TODO: Check types, field numbers, etc.? + extmap := epb.extensionsWrite() + delete(extmap, extension.Field) +} + +// GetExtension parses and returns the given extension of pb. +// If the extension is not present and has no default value it returns ErrMissingExtension. +func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) { + epb, ok := extendable(pb) + if !ok { + return nil, errors.New("proto: not an extendable proto") + } + + if err := checkExtensionTypes(epb, extension); err != nil { + return nil, err + } + + emap, mu := epb.extensionsRead() + if emap == nil { + return defaultExtensionValue(extension) + } + mu.Lock() + defer mu.Unlock() + e, ok := emap[extension.Field] + if !ok { + // defaultExtensionValue returns the default value or + // ErrMissingExtension if there is no default. + return defaultExtensionValue(extension) + } + + if e.value != nil { + // Already decoded. Check the descriptor, though. + if e.desc != extension { + // This shouldn't happen. If it does, it means that + // GetExtension was called twice with two different + // descriptors with the same field number. + return nil, errors.New("proto: descriptor conflict") + } + return e.value, nil + } + + v, err := decodeExtension(e.enc, extension) + if err != nil { + return nil, err + } + + // Remember the decoded version and drop the encoded version. + // That way it is safe to mutate what we return. + e.value = v + e.desc = extension + e.enc = nil + emap[extension.Field] = e + return e.value, nil +} + +// defaultExtensionValue returns the default value for extension. +// If no default for an extension is defined ErrMissingExtension is returned. +func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) { + t := reflect.TypeOf(extension.ExtensionType) + props := extensionProperties(extension) + + sf, _, err := fieldDefault(t, props) + if err != nil { + return nil, err + } + + if sf == nil || sf.value == nil { + // There is no default value. + return nil, ErrMissingExtension + } + + if t.Kind() != reflect.Ptr { + // We do not need to return a Ptr, we can directly return sf.value. + return sf.value, nil + } + + // We need to return an interface{} that is a pointer to sf.value. + value := reflect.New(t).Elem() + value.Set(reflect.New(value.Type().Elem())) + if sf.kind == reflect.Int32 { + // We may have an int32 or an enum, but the underlying data is int32. + // Since we can't set an int32 into a non int32 reflect.value directly + // set it as a int32. + value.Elem().SetInt(int64(sf.value.(int32))) + } else { + value.Elem().Set(reflect.ValueOf(sf.value)) + } + return value.Interface(), nil +} + +// decodeExtension decodes an extension encoded in b. +func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) { + o := NewBuffer(b) + + t := reflect.TypeOf(extension.ExtensionType) + + props := extensionProperties(extension) + + // t is a pointer to a struct, pointer to basic type or a slice. + // Allocate a "field" to store the pointer/slice itself; the + // pointer/slice will be stored here. We pass + // the address of this field to props.dec. + // This passes a zero field and a *t and lets props.dec + // interpret it as a *struct{ x t }. + value := reflect.New(t).Elem() + + for { + // Discard wire type and field number varint. It isn't needed. + if _, err := o.DecodeVarint(); err != nil { + return nil, err + } + + if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil { + return nil, err + } + + if o.index >= len(o.buf) { + break + } + } + return value.Interface(), nil +} + +// GetExtensions returns a slice of the extensions present in pb that are also listed in es. +// The returned slice has the same length as es; missing extensions will appear as nil elements. +func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) { + epb, ok := extendable(pb) + if !ok { + return nil, errors.New("proto: not an extendable proto") + } + extensions = make([]interface{}, len(es)) + for i, e := range es { + extensions[i], err = GetExtension(epb, e) + if err == ErrMissingExtension { + err = nil + } + if err != nil { + return + } + } + return +} + +// ExtensionDescs returns a new slice containing pb's extension descriptors, in undefined order. +// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing +// just the Field field, which defines the extension's field number. +func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) { + epb, ok := extendable(pb) + if !ok { + return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb) + } + registeredExtensions := RegisteredExtensions(pb) + + emap, mu := epb.extensionsRead() + if emap == nil { + return nil, nil + } + mu.Lock() + defer mu.Unlock() + extensions := make([]*ExtensionDesc, 0, len(emap)) + for extid, e := range emap { + desc := e.desc + if desc == nil { + desc = registeredExtensions[extid] + if desc == nil { + desc = &ExtensionDesc{Field: extid} + } + } + + extensions = append(extensions, desc) + } + return extensions, nil +} + +// SetExtension sets the specified extension of pb to the specified value. +func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error { + epb, ok := extendable(pb) + if !ok { + return errors.New("proto: not an extendable proto") + } + if err := checkExtensionTypes(epb, extension); err != nil { + return err + } + typ := reflect.TypeOf(extension.ExtensionType) + if typ != reflect.TypeOf(value) { + return errors.New("proto: bad extension value type") + } + // nil extension values need to be caught early, because the + // encoder can't distinguish an ErrNil due to a nil extension + // from an ErrNil due to a missing field. Extensions are + // always optional, so the encoder would just swallow the error + // and drop all the extensions from the encoded message. + if reflect.ValueOf(value).IsNil() { + return fmt.Errorf("proto: SetExtension called with nil value of type %T", value) + } + + extmap := epb.extensionsWrite() + extmap[extension.Field] = Extension{desc: extension, value: value} + return nil +} + +// ClearAllExtensions clears all extensions from pb. +func ClearAllExtensions(pb Message) { + epb, ok := extendable(pb) + if !ok { + return + } + m := epb.extensionsWrite() + for k := range m { + delete(m, k) + } +} + +// A global registry of extensions. +// The generated code will register the generated descriptors by calling RegisterExtension. + +var extensionMaps = make(map[reflect.Type]map[int32]*ExtensionDesc) + +// RegisterExtension is called from the generated code. +func RegisterExtension(desc *ExtensionDesc) { + st := reflect.TypeOf(desc.ExtendedType).Elem() + m := extensionMaps[st] + if m == nil { + m = make(map[int32]*ExtensionDesc) + extensionMaps[st] = m + } + if _, ok := m[desc.Field]; ok { + panic("proto: duplicate extension registered: " + st.String() + " " + strconv.Itoa(int(desc.Field))) + } + m[desc.Field] = desc +} + +// RegisteredExtensions returns a map of the registered extensions of a +// protocol buffer struct, indexed by the extension number. +// The argument pb should be a nil pointer to the struct type. +func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc { + return extensionMaps[reflect.TypeOf(pb).Elem()] +} diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go new file mode 100644 index 00000000..1c225504 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/lib.go @@ -0,0 +1,897 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* +Package proto converts data structures to and from the wire format of +protocol buffers. It works in concert with the Go source code generated +for .proto files by the protocol compiler. + +A summary of the properties of the protocol buffer interface +for a protocol buffer variable v: + + - Names are turned from camel_case to CamelCase for export. + - There are no methods on v to set fields; just treat + them as structure fields. + - There are getters that return a field's value if set, + and return the field's default value if unset. + The getters work even if the receiver is a nil message. + - The zero value for a struct is its correct initialization state. + All desired fields must be set before marshaling. + - A Reset() method will restore a protobuf struct to its zero state. + - Non-repeated fields are pointers to the values; nil means unset. + That is, optional or required field int32 f becomes F *int32. + - Repeated fields are slices. + - Helper functions are available to aid the setting of fields. + msg.Foo = proto.String("hello") // set field + - Constants are defined to hold the default values of all fields that + have them. They have the form Default_StructName_FieldName. + Because the getter methods handle defaulted values, + direct use of these constants should be rare. + - Enums are given type names and maps from names to values. + Enum values are prefixed by the enclosing message's name, or by the + enum's type name if it is a top-level enum. Enum types have a String + method, and a Enum method to assist in message construction. + - Nested messages, groups and enums have type names prefixed with the name of + the surrounding message type. + - Extensions are given descriptor names that start with E_, + followed by an underscore-delimited list of the nested messages + that contain it (if any) followed by the CamelCased name of the + extension field itself. HasExtension, ClearExtension, GetExtension + and SetExtension are functions for manipulating extensions. + - Oneof field sets are given a single field in their message, + with distinguished wrapper types for each possible field value. + - Marshal and Unmarshal are functions to encode and decode the wire format. + +When the .proto file specifies `syntax="proto3"`, there are some differences: + + - Non-repeated fields of non-message type are values instead of pointers. + - Enum types do not get an Enum method. + +The simplest way to describe this is to see an example. +Given file test.proto, containing + + package example; + + enum FOO { X = 17; } + + message Test { + required string label = 1; + optional int32 type = 2 [default=77]; + repeated int64 reps = 3; + optional group OptionalGroup = 4 { + required string RequiredField = 5; + } + oneof union { + int32 number = 6; + string name = 7; + } + } + +The resulting file, test.pb.go, is: + + package example + + import proto "github.com/golang/protobuf/proto" + import math "math" + + type FOO int32 + const ( + FOO_X FOO = 17 + ) + var FOO_name = map[int32]string{ + 17: "X", + } + var FOO_value = map[string]int32{ + "X": 17, + } + + func (x FOO) Enum() *FOO { + p := new(FOO) + *p = x + return p + } + func (x FOO) String() string { + return proto.EnumName(FOO_name, int32(x)) + } + func (x *FOO) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FOO_value, data) + if err != nil { + return err + } + *x = FOO(value) + return nil + } + + type Test struct { + Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` + Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` + Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` + Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` + // Types that are valid to be assigned to Union: + // *Test_Number + // *Test_Name + Union isTest_Union `protobuf_oneof:"union"` + XXX_unrecognized []byte `json:"-"` + } + func (m *Test) Reset() { *m = Test{} } + func (m *Test) String() string { return proto.CompactTextString(m) } + func (*Test) ProtoMessage() {} + + type isTest_Union interface { + isTest_Union() + } + + type Test_Number struct { + Number int32 `protobuf:"varint,6,opt,name=number"` + } + type Test_Name struct { + Name string `protobuf:"bytes,7,opt,name=name"` + } + + func (*Test_Number) isTest_Union() {} + func (*Test_Name) isTest_Union() {} + + func (m *Test) GetUnion() isTest_Union { + if m != nil { + return m.Union + } + return nil + } + const Default_Test_Type int32 = 77 + + func (m *Test) GetLabel() string { + if m != nil && m.Label != nil { + return *m.Label + } + return "" + } + + func (m *Test) GetType() int32 { + if m != nil && m.Type != nil { + return *m.Type + } + return Default_Test_Type + } + + func (m *Test) GetOptionalgroup() *Test_OptionalGroup { + if m != nil { + return m.Optionalgroup + } + return nil + } + + type Test_OptionalGroup struct { + RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` + } + func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } + func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } + + func (m *Test_OptionalGroup) GetRequiredField() string { + if m != nil && m.RequiredField != nil { + return *m.RequiredField + } + return "" + } + + func (m *Test) GetNumber() int32 { + if x, ok := m.GetUnion().(*Test_Number); ok { + return x.Number + } + return 0 + } + + func (m *Test) GetName() string { + if x, ok := m.GetUnion().(*Test_Name); ok { + return x.Name + } + return "" + } + + func init() { + proto.RegisterEnum("example.FOO", FOO_name, FOO_value) + } + +To create and play with a Test object: + + package main + + import ( + "log" + + "github.com/golang/protobuf/proto" + pb "./example.pb" + ) + + func main() { + test := &pb.Test{ + Label: proto.String("hello"), + Type: proto.Int32(17), + Reps: []int64{1, 2, 3}, + Optionalgroup: &pb.Test_OptionalGroup{ + RequiredField: proto.String("good bye"), + }, + Union: &pb.Test_Name{"fred"}, + } + data, err := proto.Marshal(test) + if err != nil { + log.Fatal("marshaling error: ", err) + } + newTest := &pb.Test{} + err = proto.Unmarshal(data, newTest) + if err != nil { + log.Fatal("unmarshaling error: ", err) + } + // Now test and newTest contain the same data. + if test.GetLabel() != newTest.GetLabel() { + log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) + } + // Use a type switch to determine which oneof was set. + switch u := test.Union.(type) { + case *pb.Test_Number: // u.Number contains the number. + case *pb.Test_Name: // u.Name contains the string. + } + // etc. + } +*/ +package proto + +import ( + "encoding/json" + "fmt" + "log" + "reflect" + "sort" + "strconv" + "sync" +) + +// Message is implemented by generated protocol buffer messages. +type Message interface { + Reset() + String() string + ProtoMessage() +} + +// Stats records allocation details about the protocol buffer encoders +// and decoders. Useful for tuning the library itself. +type Stats struct { + Emalloc uint64 // mallocs in encode + Dmalloc uint64 // mallocs in decode + Encode uint64 // number of encodes + Decode uint64 // number of decodes + Chit uint64 // number of cache hits + Cmiss uint64 // number of cache misses + Size uint64 // number of sizes +} + +// Set to true to enable stats collection. +const collectStats = false + +var stats Stats + +// GetStats returns a copy of the global Stats structure. +func GetStats() Stats { return stats } + +// A Buffer is a buffer manager for marshaling and unmarshaling +// protocol buffers. It may be reused between invocations to +// reduce memory usage. It is not necessary to use a Buffer; +// the global functions Marshal and Unmarshal create a +// temporary Buffer and are fine for most applications. +type Buffer struct { + buf []byte // encode/decode byte stream + index int // read point + + // pools of basic types to amortize allocation. + bools []bool + uint32s []uint32 + uint64s []uint64 + + // extra pools, only used with pointer_reflect.go + int32s []int32 + int64s []int64 + float32s []float32 + float64s []float64 +} + +// NewBuffer allocates a new Buffer and initializes its internal data to +// the contents of the argument slice. +func NewBuffer(e []byte) *Buffer { + return &Buffer{buf: e} +} + +// Reset resets the Buffer, ready for marshaling a new protocol buffer. +func (p *Buffer) Reset() { + p.buf = p.buf[0:0] // for reading/writing + p.index = 0 // for reading +} + +// SetBuf replaces the internal buffer with the slice, +// ready for unmarshaling the contents of the slice. +func (p *Buffer) SetBuf(s []byte) { + p.buf = s + p.index = 0 +} + +// Bytes returns the contents of the Buffer. +func (p *Buffer) Bytes() []byte { return p.buf } + +/* + * Helper routines for simplifying the creation of optional fields of basic type. + */ + +// Bool is a helper routine that allocates a new bool value +// to store v and returns a pointer to it. +func Bool(v bool) *bool { + return &v +} + +// Int32 is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it. +func Int32(v int32) *int32 { + return &v +} + +// Int is a helper routine that allocates a new int32 value +// to store v and returns a pointer to it, but unlike Int32 +// its argument value is an int. +func Int(v int) *int32 { + p := new(int32) + *p = int32(v) + return p +} + +// Int64 is a helper routine that allocates a new int64 value +// to store v and returns a pointer to it. +func Int64(v int64) *int64 { + return &v +} + +// Float32 is a helper routine that allocates a new float32 value +// to store v and returns a pointer to it. +func Float32(v float32) *float32 { + return &v +} + +// Float64 is a helper routine that allocates a new float64 value +// to store v and returns a pointer to it. +func Float64(v float64) *float64 { + return &v +} + +// Uint32 is a helper routine that allocates a new uint32 value +// to store v and returns a pointer to it. +func Uint32(v uint32) *uint32 { + return &v +} + +// Uint64 is a helper routine that allocates a new uint64 value +// to store v and returns a pointer to it. +func Uint64(v uint64) *uint64 { + return &v +} + +// String is a helper routine that allocates a new string value +// to store v and returns a pointer to it. +func String(v string) *string { + return &v +} + +// EnumName is a helper function to simplify printing protocol buffer enums +// by name. Given an enum map and a value, it returns a useful string. +func EnumName(m map[int32]string, v int32) string { + s, ok := m[v] + if ok { + return s + } + return strconv.Itoa(int(v)) +} + +// UnmarshalJSONEnum is a helper function to simplify recovering enum int values +// from their JSON-encoded representation. Given a map from the enum's symbolic +// names to its int values, and a byte buffer containing the JSON-encoded +// value, it returns an int32 that can be cast to the enum type by the caller. +// +// The function can deal with both JSON representations, numeric and symbolic. +func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { + if data[0] == '"' { + // New style: enums are strings. + var repr string + if err := json.Unmarshal(data, &repr); err != nil { + return -1, err + } + val, ok := m[repr] + if !ok { + return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) + } + return val, nil + } + // Old style: enums are ints. + var val int32 + if err := json.Unmarshal(data, &val); err != nil { + return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) + } + return val, nil +} + +// DebugPrint dumps the encoded data in b in a debugging format with a header +// including the string s. Used in testing but made available for general debugging. +func (p *Buffer) DebugPrint(s string, b []byte) { + var u uint64 + + obuf := p.buf + index := p.index + p.buf = b + p.index = 0 + depth := 0 + + fmt.Printf("\n--- %s ---\n", s) + +out: + for { + for i := 0; i < depth; i++ { + fmt.Print(" ") + } + + index := p.index + if index == len(p.buf) { + break + } + + op, err := p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: fetching op err %v\n", index, err) + break out + } + tag := op >> 3 + wire := op & 7 + + switch wire { + default: + fmt.Printf("%3d: t=%3d unknown wire=%d\n", + index, tag, wire) + break out + + case WireBytes: + var r []byte + + r, err = p.DecodeRawBytes(false) + if err != nil { + break out + } + fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r)) + if len(r) <= 6 { + for i := 0; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } else { + for i := 0; i < 3; i++ { + fmt.Printf(" %.2x", r[i]) + } + fmt.Printf(" ..") + for i := len(r) - 3; i < len(r); i++ { + fmt.Printf(" %.2x", r[i]) + } + } + fmt.Printf("\n") + + case WireFixed32: + u, err = p.DecodeFixed32() + if err != nil { + fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u) + + case WireFixed64: + u, err = p.DecodeFixed64() + if err != nil { + fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u) + + case WireVarint: + u, err = p.DecodeVarint() + if err != nil { + fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err) + break out + } + fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u) + + case WireStartGroup: + fmt.Printf("%3d: t=%3d start\n", index, tag) + depth++ + + case WireEndGroup: + depth-- + fmt.Printf("%3d: t=%3d end\n", index, tag) + } + } + + if depth != 0 { + fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth) + } + fmt.Printf("\n") + + p.buf = obuf + p.index = index +} + +// SetDefaults sets unset protocol buffer fields to their default values. +// It only modifies fields that are both unset and have defined defaults. +// It recursively sets default values in any non-nil sub-messages. +func SetDefaults(pb Message) { + setDefaults(reflect.ValueOf(pb), true, false) +} + +// v is a pointer to a struct. +func setDefaults(v reflect.Value, recur, zeros bool) { + v = v.Elem() + + defaultMu.RLock() + dm, ok := defaults[v.Type()] + defaultMu.RUnlock() + if !ok { + dm = buildDefaultMessage(v.Type()) + defaultMu.Lock() + defaults[v.Type()] = dm + defaultMu.Unlock() + } + + for _, sf := range dm.scalars { + f := v.Field(sf.index) + if !f.IsNil() { + // field already set + continue + } + dv := sf.value + if dv == nil && !zeros { + // no explicit default, and don't want to set zeros + continue + } + fptr := f.Addr().Interface() // **T + // TODO: Consider batching the allocations we do here. + switch sf.kind { + case reflect.Bool: + b := new(bool) + if dv != nil { + *b = dv.(bool) + } + *(fptr.(**bool)) = b + case reflect.Float32: + f := new(float32) + if dv != nil { + *f = dv.(float32) + } + *(fptr.(**float32)) = f + case reflect.Float64: + f := new(float64) + if dv != nil { + *f = dv.(float64) + } + *(fptr.(**float64)) = f + case reflect.Int32: + // might be an enum + if ft := f.Type(); ft != int32PtrType { + // enum + f.Set(reflect.New(ft.Elem())) + if dv != nil { + f.Elem().SetInt(int64(dv.(int32))) + } + } else { + // int32 field + i := new(int32) + if dv != nil { + *i = dv.(int32) + } + *(fptr.(**int32)) = i + } + case reflect.Int64: + i := new(int64) + if dv != nil { + *i = dv.(int64) + } + *(fptr.(**int64)) = i + case reflect.String: + s := new(string) + if dv != nil { + *s = dv.(string) + } + *(fptr.(**string)) = s + case reflect.Uint8: + // exceptional case: []byte + var b []byte + if dv != nil { + db := dv.([]byte) + b = make([]byte, len(db)) + copy(b, db) + } else { + b = []byte{} + } + *(fptr.(*[]byte)) = b + case reflect.Uint32: + u := new(uint32) + if dv != nil { + *u = dv.(uint32) + } + *(fptr.(**uint32)) = u + case reflect.Uint64: + u := new(uint64) + if dv != nil { + *u = dv.(uint64) + } + *(fptr.(**uint64)) = u + default: + log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind) + } + } + + for _, ni := range dm.nested { + f := v.Field(ni) + // f is *T or []*T or map[T]*T + switch f.Kind() { + case reflect.Ptr: + if f.IsNil() { + continue + } + setDefaults(f, recur, zeros) + + case reflect.Slice: + for i := 0; i < f.Len(); i++ { + e := f.Index(i) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + + case reflect.Map: + for _, k := range f.MapKeys() { + e := f.MapIndex(k) + if e.IsNil() { + continue + } + setDefaults(e, recur, zeros) + } + } + } +} + +var ( + // defaults maps a protocol buffer struct type to a slice of the fields, + // with its scalar fields set to their proto-declared non-zero default values. + defaultMu sync.RWMutex + defaults = make(map[reflect.Type]defaultMessage) + + int32PtrType = reflect.TypeOf((*int32)(nil)) +) + +// defaultMessage represents information about the default values of a message. +type defaultMessage struct { + scalars []scalarField + nested []int // struct field index of nested messages +} + +type scalarField struct { + index int // struct field index + kind reflect.Kind // element type (the T in *T or []T) + value interface{} // the proto-declared default value, or nil +} + +// t is a struct type. +func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { + sprop := GetProperties(t) + for _, prop := range sprop.Prop { + fi, ok := sprop.decoderTags.get(prop.Tag) + if !ok { + // XXX_unrecognized + continue + } + ft := t.Field(fi).Type + + sf, nested, err := fieldDefault(ft, prop) + switch { + case err != nil: + log.Print(err) + case nested: + dm.nested = append(dm.nested, fi) + case sf != nil: + sf.index = fi + dm.scalars = append(dm.scalars, *sf) + } + } + + return dm +} + +// fieldDefault returns the scalarField for field type ft. +// sf will be nil if the field can not have a default. +// nestedMessage will be true if this is a nested message. +// Note that sf.index is not set on return. +func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) { + var canHaveDefault bool + switch ft.Kind() { + case reflect.Ptr: + if ft.Elem().Kind() == reflect.Struct { + nestedMessage = true + } else { + canHaveDefault = true // proto2 scalar field + } + + case reflect.Slice: + switch ft.Elem().Kind() { + case reflect.Ptr: + nestedMessage = true // repeated message + case reflect.Uint8: + canHaveDefault = true // bytes field + } + + case reflect.Map: + if ft.Elem().Kind() == reflect.Ptr { + nestedMessage = true // map with message values + } + } + + if !canHaveDefault { + if nestedMessage { + return nil, true, nil + } + return nil, false, nil + } + + // We now know that ft is a pointer or slice. + sf = &scalarField{kind: ft.Elem().Kind()} + + // scalar fields without defaults + if !prop.HasDefault { + return sf, false, nil + } + + // a scalar field: either *T or []byte + switch ft.Elem().Kind() { + case reflect.Bool: + x, err := strconv.ParseBool(prop.Default) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Float32: + x, err := strconv.ParseFloat(prop.Default, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err) + } + sf.value = float32(x) + case reflect.Float64: + x, err := strconv.ParseFloat(prop.Default, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.Int32: + x, err := strconv.ParseInt(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err) + } + sf.value = int32(x) + case reflect.Int64: + x, err := strconv.ParseInt(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err) + } + sf.value = x + case reflect.String: + sf.value = prop.Default + case reflect.Uint8: + // []byte (not *uint8) + sf.value = []byte(prop.Default) + case reflect.Uint32: + x, err := strconv.ParseUint(prop.Default, 10, 32) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err) + } + sf.value = uint32(x) + case reflect.Uint64: + x, err := strconv.ParseUint(prop.Default, 10, 64) + if err != nil { + return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err) + } + sf.value = x + default: + return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind()) + } + + return sf, false, nil +} + +// Map fields may have key types of non-float scalars, strings and enums. +// The easiest way to sort them in some deterministic order is to use fmt. +// If this turns out to be inefficient we can always consider other options, +// such as doing a Schwartzian transform. + +func mapKeys(vs []reflect.Value) sort.Interface { + s := mapKeySorter{ + vs: vs, + // default Less function: textual comparison + less: func(a, b reflect.Value) bool { + return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface()) + }, + } + + // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps; + // numeric keys are sorted numerically. + if len(vs) == 0 { + return s + } + switch vs[0].Kind() { + case reflect.Int32, reflect.Int64: + s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() } + case reflect.Uint32, reflect.Uint64: + s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() } + } + + return s +} + +type mapKeySorter struct { + vs []reflect.Value + less func(a, b reflect.Value) bool +} + +func (s mapKeySorter) Len() int { return len(s.vs) } +func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] } +func (s mapKeySorter) Less(i, j int) bool { + return s.less(s.vs[i], s.vs[j]) +} + +// isProto3Zero reports whether v is a zero proto3 value. +func isProto3Zero(v reflect.Value) bool { + switch v.Kind() { + case reflect.Bool: + return !v.Bool() + case reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint32, reflect.Uint64: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.String: + return v.String() == "" + } + return false +} + +// ProtoPackageIsVersion2 is referenced from generated protocol buffer files +// to assert that that code is compatible with this version of the proto package. +const ProtoPackageIsVersion2 = true + +// ProtoPackageIsVersion1 is referenced from generated protocol buffer files +// to assert that that code is compatible with this version of the proto package. +const ProtoPackageIsVersion1 = true diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go new file mode 100644 index 00000000..fd982dec --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/message_set.go @@ -0,0 +1,311 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Support for message sets. + */ + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "reflect" + "sort" +) + +// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID. +// A message type ID is required for storing a protocol buffer in a message set. +var errNoMessageTypeID = errors.New("proto does not have a message type ID") + +// The first two types (_MessageSet_Item and messageSet) +// model what the protocol compiler produces for the following protocol message: +// message MessageSet { +// repeated group Item = 1 { +// required int32 type_id = 2; +// required string message = 3; +// }; +// } +// That is the MessageSet wire format. We can't use a proto to generate these +// because that would introduce a circular dependency between it and this package. + +type _MessageSet_Item struct { + TypeId *int32 `protobuf:"varint,2,req,name=type_id"` + Message []byte `protobuf:"bytes,3,req,name=message"` +} + +type messageSet struct { + Item []*_MessageSet_Item `protobuf:"group,1,rep"` + XXX_unrecognized []byte + // TODO: caching? +} + +// Make sure messageSet is a Message. +var _ Message = (*messageSet)(nil) + +// messageTypeIder is an interface satisfied by a protocol buffer type +// that may be stored in a MessageSet. +type messageTypeIder interface { + MessageTypeId() int32 +} + +func (ms *messageSet) find(pb Message) *_MessageSet_Item { + mti, ok := pb.(messageTypeIder) + if !ok { + return nil + } + id := mti.MessageTypeId() + for _, item := range ms.Item { + if *item.TypeId == id { + return item + } + } + return nil +} + +func (ms *messageSet) Has(pb Message) bool { + if ms.find(pb) != nil { + return true + } + return false +} + +func (ms *messageSet) Unmarshal(pb Message) error { + if item := ms.find(pb); item != nil { + return Unmarshal(item.Message, pb) + } + if _, ok := pb.(messageTypeIder); !ok { + return errNoMessageTypeID + } + return nil // TODO: return error instead? +} + +func (ms *messageSet) Marshal(pb Message) error { + msg, err := Marshal(pb) + if err != nil { + return err + } + if item := ms.find(pb); item != nil { + // reuse existing item + item.Message = msg + return nil + } + + mti, ok := pb.(messageTypeIder) + if !ok { + return errNoMessageTypeID + } + + mtid := mti.MessageTypeId() + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: &mtid, + Message: msg, + }) + return nil +} + +func (ms *messageSet) Reset() { *ms = messageSet{} } +func (ms *messageSet) String() string { return CompactTextString(ms) } +func (*messageSet) ProtoMessage() {} + +// Support for the message_set_wire_format message option. + +func skipVarint(buf []byte) []byte { + i := 0 + for ; buf[i]&0x80 != 0; i++ { + } + return buf[i+1:] +} + +// MarshalMessageSet encodes the extension map represented by m in the message set wire format. +// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSet(exts interface{}) ([]byte, error) { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + if err := encodeExtensions(exts); err != nil { + return nil, err + } + m, _ = exts.extensionsRead() + case map[int32]Extension: + if err := encodeExtensionsMap(exts); err != nil { + return nil, err + } + m = exts + default: + return nil, errors.New("proto: not an extension map") + } + + // Sort extension IDs to provide a deterministic encoding. + // See also enc_map in encode.go. + ids := make([]int, 0, len(m)) + for id := range m { + ids = append(ids, int(id)) + } + sort.Ints(ids) + + ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))} + for _, id := range ids { + e := m[int32(id)] + // Remove the wire type and field number varint, as well as the length varint. + msg := skipVarint(skipVarint(e.enc)) + + ms.Item = append(ms.Item, &_MessageSet_Item{ + TypeId: Int32(int32(id)), + Message: msg, + }) + } + return Marshal(ms) +} + +// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format. +// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSet(buf []byte, exts interface{}) error { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + m = exts.extensionsWrite() + case map[int32]Extension: + m = exts + default: + return errors.New("proto: not an extension map") + } + + ms := new(messageSet) + if err := Unmarshal(buf, ms); err != nil { + return err + } + for _, item := range ms.Item { + id := *item.TypeId + msg := item.Message + + // Restore wire type and field number varint, plus length varint. + // Be careful to preserve duplicate items. + b := EncodeVarint(uint64(id)<<3 | WireBytes) + if ext, ok := m[id]; ok { + // Existing data; rip off the tag and length varint + // so we join the new data correctly. + // We can assume that ext.enc is set because we are unmarshaling. + o := ext.enc[len(b):] // skip wire type and field number + _, n := DecodeVarint(o) // calculate length of length varint + o = o[n:] // skip length varint + msg = append(o, msg...) // join old data and new data + } + b = append(b, EncodeVarint(uint64(len(msg)))...) + b = append(b, msg...) + + m[id] = Extension{enc: b} + } + return nil +} + +// MarshalMessageSetJSON encodes the extension map represented by m in JSON format. +// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func MarshalMessageSetJSON(exts interface{}) ([]byte, error) { + var m map[int32]Extension + switch exts := exts.(type) { + case *XXX_InternalExtensions: + m, _ = exts.extensionsRead() + case map[int32]Extension: + m = exts + default: + return nil, errors.New("proto: not an extension map") + } + var b bytes.Buffer + b.WriteByte('{') + + // Process the map in key order for deterministic output. + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) // int32Slice defined in text.go + + for i, id := range ids { + ext := m[id] + if i > 0 { + b.WriteByte(',') + } + + msd, ok := messageSetMap[id] + if !ok { + // Unknown type; we can't render it, so skip it. + continue + } + fmt.Fprintf(&b, `"[%s]":`, msd.name) + + x := ext.value + if x == nil { + x = reflect.New(msd.t.Elem()).Interface() + if err := Unmarshal(ext.enc, x.(Message)); err != nil { + return nil, err + } + } + d, err := json.Marshal(x) + if err != nil { + return nil, err + } + b.Write(d) + } + b.WriteByte('}') + return b.Bytes(), nil +} + +// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format. +// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option. +func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error { + // Common-case fast path. + if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) { + return nil + } + + // This is fairly tricky, and it's not clear that it is needed. + return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented") +} + +// A global registry of types that can be used in a MessageSet. + +var messageSetMap = make(map[int32]messageSetDesc) + +type messageSetDesc struct { + t reflect.Type // pointer to struct + name string +} + +// RegisterMessageSetType is called from the generated code. +func RegisterMessageSetType(m Message, fieldNum int32, name string) { + messageSetMap[fieldNum] = messageSetDesc{ + t: reflect.TypeOf(m), + name: name, + } +} diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go new file mode 100644 index 00000000..fb512e2e --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go @@ -0,0 +1,484 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// +build appengine js + +// This file contains an implementation of proto field accesses using package reflect. +// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can +// be used on App Engine. + +package proto + +import ( + "math" + "reflect" +) + +// A structPointer is a pointer to a struct. +type structPointer struct { + v reflect.Value +} + +// toStructPointer returns a structPointer equivalent to the given reflect value. +// The reflect value must itself be a pointer to a struct. +func toStructPointer(v reflect.Value) structPointer { + return structPointer{v} +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p.v.IsNil() +} + +// Interface returns the struct pointer as an interface value. +func structPointer_Interface(p structPointer, _ reflect.Type) interface{} { + return p.v.Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by the sequence of field indices +// passed to reflect's FieldByIndex. +type field []int + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return f.Index +} + +// invalidField is an invalid field identifier. +var invalidField = field(nil) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { return f != nil } + +// field returns the given field in the struct as a reflect value. +func structPointer_field(p structPointer, f field) reflect.Value { + // Special case: an extension map entry with a value of type T + // passes a *T to the struct-handling code with a zero field, + // expecting that it will be treated as equivalent to *struct{ X T }, + // which has the same memory layout. We have to handle that case + // specially, because reflect will panic if we call FieldByIndex on a + // non-struct. + if f == nil { + return p.v.Elem() + } + + return p.v.Elem().FieldByIndex(f) +} + +// ifield returns the given field in the struct as an interface value. +func structPointer_ifield(p structPointer, f field) interface{} { + return structPointer_field(p, f).Addr().Interface() +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return structPointer_ifield(p, f).(*[]byte) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return structPointer_ifield(p, f).(*[][]byte) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return structPointer_ifield(p, f).(**bool) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return structPointer_ifield(p, f).(*bool) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return structPointer_ifield(p, f).(*[]bool) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return structPointer_ifield(p, f).(**string) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return structPointer_ifield(p, f).(*string) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return structPointer_ifield(p, f).(*[]string) +} + +// Extensions returns the address of an extension map field in the struct. +func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { + return structPointer_ifield(p, f).(*XXX_InternalExtensions) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return structPointer_ifield(p, f).(*map[int32]Extension) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return structPointer_field(p, f).Addr() +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + structPointer_field(p, f).Set(q.v) +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return structPointer{structPointer_field(p, f)} +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice { + return structPointerSlice{structPointer_field(p, f)} +} + +// A structPointerSlice represents the address of a slice of pointers to structs +// (themselves messages or groups). That is, v.Type() is *[]*struct{...}. +type structPointerSlice struct { + v reflect.Value +} + +func (p structPointerSlice) Len() int { return p.v.Len() } +func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} } +func (p structPointerSlice) Append(q structPointer) { + p.v.Set(reflect.Append(p.v, q.v)) +} + +var ( + int32Type = reflect.TypeOf(int32(0)) + uint32Type = reflect.TypeOf(uint32(0)) + float32Type = reflect.TypeOf(float32(0)) + int64Type = reflect.TypeOf(int64(0)) + uint64Type = reflect.TypeOf(uint64(0)) + float64Type = reflect.TypeOf(float64(0)) +) + +// A word32 represents a field of type *int32, *uint32, *float32, or *enum. +// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable. +type word32 struct { + v reflect.Value +} + +// IsNil reports whether p is nil. +func word32_IsNil(p word32) bool { + return p.v.IsNil() +} + +// Set sets p to point at a newly allocated word with bits set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + t := p.v.Type().Elem() + switch t { + case int32Type: + if len(o.int32s) == 0 { + o.int32s = make([]int32, uint32PoolSize) + } + o.int32s[0] = int32(x) + p.v.Set(reflect.ValueOf(&o.int32s[0])) + o.int32s = o.int32s[1:] + return + case uint32Type: + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + p.v.Set(reflect.ValueOf(&o.uint32s[0])) + o.uint32s = o.uint32s[1:] + return + case float32Type: + if len(o.float32s) == 0 { + o.float32s = make([]float32, uint32PoolSize) + } + o.float32s[0] = math.Float32frombits(x) + p.v.Set(reflect.ValueOf(&o.float32s[0])) + o.float32s = o.float32s[1:] + return + } + + // must be enum + p.v.Set(reflect.New(t)) + p.v.Elem().SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32_Get(p word32) uint32 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32{structPointer_field(p, f)} +} + +// A word32Val represents a field of type int32, uint32, float32, or enum. +// That is, v.Type() is int32, uint32, float32, or enum and v is assignable. +type word32Val struct { + v reflect.Value +} + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + switch p.v.Type() { + case int32Type: + p.v.SetInt(int64(x)) + return + case uint32Type: + p.v.SetUint(uint64(x)) + return + case float32Type: + p.v.SetFloat(float64(math.Float32frombits(x))) + return + } + + // must be enum + p.v.SetInt(int64(int32(x))) +} + +// Get gets the bits pointed at by p, as a uint32. +func word32Val_Get(p word32Val) uint32 { + elem := p.v + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val{structPointer_field(p, f)} +} + +// A word32Slice is a slice of 32-bit values. +// That is, v.Type() is []int32, []uint32, []float32, or []enum. +type word32Slice struct { + v reflect.Value +} + +func (p word32Slice) Append(x uint32) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int32: + elem.SetInt(int64(int32(x))) + case reflect.Uint32: + elem.SetUint(uint64(x)) + case reflect.Float32: + elem.SetFloat(float64(math.Float32frombits(x))) + } +} + +func (p word32Slice) Len() int { + return p.v.Len() +} + +func (p word32Slice) Index(i int) uint32 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int32: + return uint32(elem.Int()) + case reflect.Uint32: + return uint32(elem.Uint()) + case reflect.Float32: + return math.Float32bits(float32(elem.Float())) + } + panic("unreachable") +} + +// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) word32Slice { + return word32Slice{structPointer_field(p, f)} +} + +// word64 is like word32 but for 64-bit values. +type word64 struct { + v reflect.Value +} + +func word64_Set(p word64, o *Buffer, x uint64) { + t := p.v.Type().Elem() + switch t { + case int64Type: + if len(o.int64s) == 0 { + o.int64s = make([]int64, uint64PoolSize) + } + o.int64s[0] = int64(x) + p.v.Set(reflect.ValueOf(&o.int64s[0])) + o.int64s = o.int64s[1:] + return + case uint64Type: + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + p.v.Set(reflect.ValueOf(&o.uint64s[0])) + o.uint64s = o.uint64s[1:] + return + case float64Type: + if len(o.float64s) == 0 { + o.float64s = make([]float64, uint64PoolSize) + } + o.float64s[0] = math.Float64frombits(x) + p.v.Set(reflect.ValueOf(&o.float64s[0])) + o.float64s = o.float64s[1:] + return + } + panic("unreachable") +} + +func word64_IsNil(p word64) bool { + return p.v.IsNil() +} + +func word64_Get(p word64) uint64 { + elem := p.v.Elem() + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64{structPointer_field(p, f)} +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val struct { + v reflect.Value +} + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + switch p.v.Type() { + case int64Type: + p.v.SetInt(int64(x)) + return + case uint64Type: + p.v.SetUint(x) + return + case float64Type: + p.v.SetFloat(math.Float64frombits(x)) + return + } + panic("unreachable") +} + +func word64Val_Get(p word64Val) uint64 { + elem := p.v + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return elem.Uint() + case reflect.Float64: + return math.Float64bits(elem.Float()) + } + panic("unreachable") +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val{structPointer_field(p, f)} +} + +type word64Slice struct { + v reflect.Value +} + +func (p word64Slice) Append(x uint64) { + n, m := p.v.Len(), p.v.Cap() + if n < m { + p.v.SetLen(n + 1) + } else { + t := p.v.Type().Elem() + p.v.Set(reflect.Append(p.v, reflect.Zero(t))) + } + elem := p.v.Index(n) + switch elem.Kind() { + case reflect.Int64: + elem.SetInt(int64(int64(x))) + case reflect.Uint64: + elem.SetUint(uint64(x)) + case reflect.Float64: + elem.SetFloat(float64(math.Float64frombits(x))) + } +} + +func (p word64Slice) Len() int { + return p.v.Len() +} + +func (p word64Slice) Index(i int) uint64 { + elem := p.v.Index(i) + switch elem.Kind() { + case reflect.Int64: + return uint64(elem.Int()) + case reflect.Uint64: + return uint64(elem.Uint()) + case reflect.Float64: + return math.Float64bits(float64(elem.Float())) + } + panic("unreachable") +} + +func structPointer_Word64Slice(p structPointer, f field) word64Slice { + return word64Slice{structPointer_field(p, f)} +} diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go new file mode 100644 index 00000000..6b5567d4 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go @@ -0,0 +1,270 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2012 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// +build !appengine,!js + +// This file contains the implementation of the proto field accesses using package unsafe. + +package proto + +import ( + "reflect" + "unsafe" +) + +// NOTE: These type_Foo functions would more idiomatically be methods, +// but Go does not allow methods on pointer types, and we must preserve +// some pointer type for the garbage collector. We use these +// funcs with clunky names as our poor approximation to methods. +// +// An alternative would be +// type structPointer struct { p unsafe.Pointer } +// but that does not registerize as well. + +// A structPointer is a pointer to a struct. +type structPointer unsafe.Pointer + +// toStructPointer returns a structPointer equivalent to the given reflect value. +func toStructPointer(v reflect.Value) structPointer { + return structPointer(unsafe.Pointer(v.Pointer())) +} + +// IsNil reports whether p is nil. +func structPointer_IsNil(p structPointer) bool { + return p == nil +} + +// Interface returns the struct pointer, assumed to have element type t, +// as an interface value. +func structPointer_Interface(p structPointer, t reflect.Type) interface{} { + return reflect.NewAt(t, unsafe.Pointer(p)).Interface() +} + +// A field identifies a field in a struct, accessible from a structPointer. +// In this implementation, a field is identified by its byte offset from the start of the struct. +type field uintptr + +// toField returns a field equivalent to the given reflect field. +func toField(f *reflect.StructField) field { + return field(f.Offset) +} + +// invalidField is an invalid field identifier. +const invalidField = ^field(0) + +// IsValid reports whether the field identifier is valid. +func (f field) IsValid() bool { + return f != ^field(0) +} + +// Bytes returns the address of a []byte field in the struct. +func structPointer_Bytes(p structPointer, f field) *[]byte { + return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BytesSlice returns the address of a [][]byte field in the struct. +func structPointer_BytesSlice(p structPointer, f field) *[][]byte { + return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// Bool returns the address of a *bool field in the struct. +func structPointer_Bool(p structPointer, f field) **bool { + return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolVal returns the address of a bool field in the struct. +func structPointer_BoolVal(p structPointer, f field) *bool { + return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// BoolSlice returns the address of a []bool field in the struct. +func structPointer_BoolSlice(p structPointer, f field) *[]bool { + return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// String returns the address of a *string field in the struct. +func structPointer_String(p structPointer, f field) **string { + return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringVal returns the address of a string field in the struct. +func structPointer_StringVal(p structPointer, f field) *string { + return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StringSlice returns the address of a []string field in the struct. +func structPointer_StringSlice(p structPointer, f field) *[]string { + return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// ExtMap returns the address of an extension map field in the struct. +func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions { + return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { + return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// NewAt returns the reflect.Value for a pointer to a field in the struct. +func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value { + return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f))) +} + +// SetStructPointer writes a *struct field in the struct. +func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { + *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q +} + +// GetStructPointer reads a *struct field in the struct. +func structPointer_GetStructPointer(p structPointer, f field) structPointer { + return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// StructPointerSlice the address of a []*struct field in the struct. +func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice { + return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups). +type structPointerSlice []structPointer + +func (v *structPointerSlice) Len() int { return len(*v) } +func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] } +func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) } + +// A word32 is the address of a "pointer to 32-bit value" field. +type word32 **uint32 + +// IsNil reports whether *v is nil. +func word32_IsNil(p word32) bool { + return *p == nil +} + +// Set sets *v to point at a newly allocated word set to x. +func word32_Set(p word32, o *Buffer, x uint32) { + if len(o.uint32s) == 0 { + o.uint32s = make([]uint32, uint32PoolSize) + } + o.uint32s[0] = x + *p = &o.uint32s[0] + o.uint32s = o.uint32s[1:] +} + +// Get gets the value pointed at by *v. +func word32_Get(p word32) uint32 { + return **p +} + +// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32(p structPointer, f field) word32 { + return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Val is the address of a 32-bit value field. +type word32Val *uint32 + +// Set sets *p to x. +func word32Val_Set(p word32Val, x uint32) { + *p = x +} + +// Get gets the value pointed at by p. +func word32Val_Get(p word32Val) uint32 { + return *p +} + +// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct. +func structPointer_Word32Val(p structPointer, f field) word32Val { + return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// A word32Slice is a slice of 32-bit values. +type word32Slice []uint32 + +func (v *word32Slice) Append(x uint32) { *v = append(*v, x) } +func (v *word32Slice) Len() int { return len(*v) } +func (v *word32Slice) Index(i int) uint32 { return (*v)[i] } + +// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct. +func structPointer_Word32Slice(p structPointer, f field) *word32Slice { + return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} + +// word64 is like word32 but for 64-bit values. +type word64 **uint64 + +func word64_Set(p word64, o *Buffer, x uint64) { + if len(o.uint64s) == 0 { + o.uint64s = make([]uint64, uint64PoolSize) + } + o.uint64s[0] = x + *p = &o.uint64s[0] + o.uint64s = o.uint64s[1:] +} + +func word64_IsNil(p word64) bool { + return *p == nil +} + +func word64_Get(p word64) uint64 { + return **p +} + +func structPointer_Word64(p structPointer, f field) word64 { + return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Val is like word32Val but for 64-bit values. +type word64Val *uint64 + +func word64Val_Set(p word64Val, o *Buffer, x uint64) { + *p = x +} + +func word64Val_Get(p word64Val) uint64 { + return *p +} + +func structPointer_Word64Val(p structPointer, f field) word64Val { + return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) +} + +// word64Slice is like word32Slice but for 64-bit values. +type word64Slice []uint64 + +func (v *word64Slice) Append(x uint64) { *v = append(*v, x) } +func (v *word64Slice) Len() int { return len(*v) } +func (v *word64Slice) Index(i int) uint64 { return (*v)[i] } + +func structPointer_Word64Slice(p structPointer, f field) *word64Slice { + return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) +} diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go new file mode 100644 index 00000000..ec2289c0 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/properties.go @@ -0,0 +1,872 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +/* + * Routines for encoding data into the wire format for protocol buffers. + */ + +import ( + "fmt" + "log" + "os" + "reflect" + "sort" + "strconv" + "strings" + "sync" +) + +const debug bool = false + +// Constants that identify the encoding of a value on the wire. +const ( + WireVarint = 0 + WireFixed64 = 1 + WireBytes = 2 + WireStartGroup = 3 + WireEndGroup = 4 + WireFixed32 = 5 +) + +const startSize = 10 // initial slice/string sizes + +// Encoders are defined in encode.go +// An encoder outputs the full representation of a field, including its +// tag and encoder type. +type encoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueEncoder encodes a single integer in a particular encoding. +type valueEncoder func(o *Buffer, x uint64) error + +// Sizers are defined in encode.go +// A sizer returns the encoded size of a field, including its tag and encoder +// type. +type sizer func(prop *Properties, base structPointer) int + +// A valueSizer returns the encoded size of a single integer in a particular +// encoding. +type valueSizer func(x uint64) int + +// Decoders are defined in decode.go +// A decoder creates a value from its wire representation. +// Unrecognized subelements are saved in unrec. +type decoder func(p *Buffer, prop *Properties, base structPointer) error + +// A valueDecoder decodes a single integer in a particular encoding. +type valueDecoder func(o *Buffer) (x uint64, err error) + +// A oneofMarshaler does the marshaling for all oneof fields in a message. +type oneofMarshaler func(Message, *Buffer) error + +// A oneofUnmarshaler does the unmarshaling for a oneof field in a message. +type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error) + +// A oneofSizer does the sizing for all oneof fields in a message. +type oneofSizer func(Message) int + +// tagMap is an optimization over map[int]int for typical protocol buffer +// use-cases. Encoded protocol buffers are often in tag order with small tag +// numbers. +type tagMap struct { + fastTags []int + slowTags map[int]int +} + +// tagMapFastLimit is the upper bound on the tag number that will be stored in +// the tagMap slice rather than its map. +const tagMapFastLimit = 1024 + +func (p *tagMap) get(t int) (int, bool) { + if t > 0 && t < tagMapFastLimit { + if t >= len(p.fastTags) { + return 0, false + } + fi := p.fastTags[t] + return fi, fi >= 0 + } + fi, ok := p.slowTags[t] + return fi, ok +} + +func (p *tagMap) put(t int, fi int) { + if t > 0 && t < tagMapFastLimit { + for len(p.fastTags) < t+1 { + p.fastTags = append(p.fastTags, -1) + } + p.fastTags[t] = fi + return + } + if p.slowTags == nil { + p.slowTags = make(map[int]int) + } + p.slowTags[t] = fi +} + +// StructProperties represents properties for all the fields of a struct. +// decoderTags and decoderOrigNames should only be used by the decoder. +type StructProperties struct { + Prop []*Properties // properties for each field + reqCount int // required count + decoderTags tagMap // map from proto tag to struct field number + decoderOrigNames map[string]int // map from original name to struct field number + order []int // list of struct field numbers in tag order + unrecField field // field id of the XXX_unrecognized []byte field + extendable bool // is this an extendable proto + + oneofMarshaler oneofMarshaler + oneofUnmarshaler oneofUnmarshaler + oneofSizer oneofSizer + stype reflect.Type + + // OneofTypes contains information about the oneof fields in this message. + // It is keyed by the original name of a field. + OneofTypes map[string]*OneofProperties +} + +// OneofProperties represents information about a specific field in a oneof. +type OneofProperties struct { + Type reflect.Type // pointer to generated struct type for this oneof field + Field int // struct field number of the containing oneof in the message + Prop *Properties +} + +// Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec. +// See encode.go, (*Buffer).enc_struct. + +func (sp *StructProperties) Len() int { return len(sp.order) } +func (sp *StructProperties) Less(i, j int) bool { + return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag +} +func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] } + +// Properties represents the protocol-specific behavior of a single struct field. +type Properties struct { + Name string // name of the field, for error messages + OrigName string // original name before protocol compiler (always set) + JSONName string // name to use for JSON; determined by protoc + Wire string + WireType int + Tag int + Required bool + Optional bool + Repeated bool + Packed bool // relevant for repeated primitives only + Enum string // set for enum types only + proto3 bool // whether this is known to be a proto3 field; set for []byte only + oneof bool // whether this is a oneof field + + Default string // default value + HasDefault bool // whether an explicit default was provided + def_uint64 uint64 + + enc encoder + valEnc valueEncoder // set for bool and numeric types only + field field + tagcode []byte // encoding of EncodeVarint((Tag<<3)|WireType) + tagbuf [8]byte + stype reflect.Type // set for struct types only + sprop *StructProperties // set for struct types only + isMarshaler bool + isUnmarshaler bool + + mtype reflect.Type // set for map types only + mkeyprop *Properties // set for map types only + mvalprop *Properties // set for map types only + + size sizer + valSize valueSizer // set for bool and numeric types only + + dec decoder + valDec valueDecoder // set for bool and numeric types only + + // If this is a packable field, this will be the decoder for the packed version of the field. + packedDec decoder +} + +// String formats the properties in the protobuf struct field tag style. +func (p *Properties) String() string { + s := p.Wire + s = "," + s += strconv.Itoa(p.Tag) + if p.Required { + s += ",req" + } + if p.Optional { + s += ",opt" + } + if p.Repeated { + s += ",rep" + } + if p.Packed { + s += ",packed" + } + s += ",name=" + p.OrigName + if p.JSONName != p.OrigName { + s += ",json=" + p.JSONName + } + if p.proto3 { + s += ",proto3" + } + if p.oneof { + s += ",oneof" + } + if len(p.Enum) > 0 { + s += ",enum=" + p.Enum + } + if p.HasDefault { + s += ",def=" + p.Default + } + return s +} + +// Parse populates p by parsing a string in the protobuf struct field tag style. +func (p *Properties) Parse(s string) { + // "bytes,49,opt,name=foo,def=hello!" + fields := strings.Split(s, ",") // breaks def=, but handled below. + if len(fields) < 2 { + fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s) + return + } + + p.Wire = fields[0] + switch p.Wire { + case "varint": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeVarint + p.valDec = (*Buffer).DecodeVarint + p.valSize = sizeVarint + case "fixed32": + p.WireType = WireFixed32 + p.valEnc = (*Buffer).EncodeFixed32 + p.valDec = (*Buffer).DecodeFixed32 + p.valSize = sizeFixed32 + case "fixed64": + p.WireType = WireFixed64 + p.valEnc = (*Buffer).EncodeFixed64 + p.valDec = (*Buffer).DecodeFixed64 + p.valSize = sizeFixed64 + case "zigzag32": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag32 + p.valDec = (*Buffer).DecodeZigzag32 + p.valSize = sizeZigzag32 + case "zigzag64": + p.WireType = WireVarint + p.valEnc = (*Buffer).EncodeZigzag64 + p.valDec = (*Buffer).DecodeZigzag64 + p.valSize = sizeZigzag64 + case "bytes", "group": + p.WireType = WireBytes + // no numeric converter for non-numeric types + default: + fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s) + return + } + + var err error + p.Tag, err = strconv.Atoi(fields[1]) + if err != nil { + return + } + + for i := 2; i < len(fields); i++ { + f := fields[i] + switch { + case f == "req": + p.Required = true + case f == "opt": + p.Optional = true + case f == "rep": + p.Repeated = true + case f == "packed": + p.Packed = true + case strings.HasPrefix(f, "name="): + p.OrigName = f[5:] + case strings.HasPrefix(f, "json="): + p.JSONName = f[5:] + case strings.HasPrefix(f, "enum="): + p.Enum = f[5:] + case f == "proto3": + p.proto3 = true + case f == "oneof": + p.oneof = true + case strings.HasPrefix(f, "def="): + p.HasDefault = true + p.Default = f[4:] // rest of string + if i+1 < len(fields) { + // Commas aren't escaped, and def is always last. + p.Default += "," + strings.Join(fields[i+1:], ",") + break + } + } + } +} + +func logNoSliceEnc(t1, t2 reflect.Type) { + fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2) +} + +var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem() + +// Initialize the fields for encoding and decoding. +func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) { + p.enc = nil + p.dec = nil + p.size = nil + + switch t1 := typ; t1.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1) + + // proto3 scalar types + + case reflect.Bool: + p.enc = (*Buffer).enc_proto3_bool + p.dec = (*Buffer).dec_proto3_bool + p.size = size_proto3_bool + case reflect.Int32: + p.enc = (*Buffer).enc_proto3_int32 + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_int32 + case reflect.Uint32: + p.enc = (*Buffer).enc_proto3_uint32 + p.dec = (*Buffer).dec_proto3_int32 // can reuse + p.size = size_proto3_uint32 + case reflect.Int64, reflect.Uint64: + p.enc = (*Buffer).enc_proto3_int64 + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + case reflect.Float32: + p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int32 + p.size = size_proto3_uint32 + case reflect.Float64: + p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits + p.dec = (*Buffer).dec_proto3_int64 + p.size = size_proto3_int64 + case reflect.String: + p.enc = (*Buffer).enc_proto3_string + p.dec = (*Buffer).dec_proto3_string + p.size = size_proto3_string + + case reflect.Ptr: + switch t2 := t1.Elem(); t2.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2) + break + case reflect.Bool: + p.enc = (*Buffer).enc_bool + p.dec = (*Buffer).dec_bool + p.size = size_bool + case reflect.Int32: + p.enc = (*Buffer).enc_int32 + p.dec = (*Buffer).dec_int32 + p.size = size_int32 + case reflect.Uint32: + p.enc = (*Buffer).enc_uint32 + p.dec = (*Buffer).dec_int32 // can reuse + p.size = size_uint32 + case reflect.Int64, reflect.Uint64: + p.enc = (*Buffer).enc_int64 + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.Float32: + p.enc = (*Buffer).enc_uint32 // can just treat them as bits + p.dec = (*Buffer).dec_int32 + p.size = size_uint32 + case reflect.Float64: + p.enc = (*Buffer).enc_int64 // can just treat them as bits + p.dec = (*Buffer).dec_int64 + p.size = size_int64 + case reflect.String: + p.enc = (*Buffer).enc_string + p.dec = (*Buffer).dec_string + p.size = size_string + case reflect.Struct: + p.stype = t1.Elem() + p.isMarshaler = isMarshaler(t1) + p.isUnmarshaler = isUnmarshaler(t1) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_struct_message + p.dec = (*Buffer).dec_struct_message + p.size = size_struct_message + } else { + p.enc = (*Buffer).enc_struct_group + p.dec = (*Buffer).dec_struct_group + p.size = size_struct_group + } + } + + case reflect.Slice: + switch t2 := t1.Elem(); t2.Kind() { + default: + logNoSliceEnc(t1, t2) + break + case reflect.Bool: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_bool + p.size = size_slice_packed_bool + } else { + p.enc = (*Buffer).enc_slice_bool + p.size = size_slice_bool + } + p.dec = (*Buffer).dec_slice_bool + p.packedDec = (*Buffer).dec_slice_packed_bool + case reflect.Int32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int32 + p.size = size_slice_packed_int32 + } else { + p.enc = (*Buffer).enc_slice_int32 + p.size = size_slice_int32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Uint32: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case reflect.Int64, reflect.Uint64: + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + case reflect.Uint8: + p.dec = (*Buffer).dec_slice_byte + if p.proto3 { + p.enc = (*Buffer).enc_proto3_slice_byte + p.size = size_proto3_slice_byte + } else { + p.enc = (*Buffer).enc_slice_byte + p.size = size_slice_byte + } + case reflect.Float32, reflect.Float64: + switch t2.Bits() { + case 32: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_uint32 + p.size = size_slice_packed_uint32 + } else { + p.enc = (*Buffer).enc_slice_uint32 + p.size = size_slice_uint32 + } + p.dec = (*Buffer).dec_slice_int32 + p.packedDec = (*Buffer).dec_slice_packed_int32 + case 64: + // can just treat them as bits + if p.Packed { + p.enc = (*Buffer).enc_slice_packed_int64 + p.size = size_slice_packed_int64 + } else { + p.enc = (*Buffer).enc_slice_int64 + p.size = size_slice_int64 + } + p.dec = (*Buffer).dec_slice_int64 + p.packedDec = (*Buffer).dec_slice_packed_int64 + default: + logNoSliceEnc(t1, t2) + break + } + case reflect.String: + p.enc = (*Buffer).enc_slice_string + p.dec = (*Buffer).dec_slice_string + p.size = size_slice_string + case reflect.Ptr: + switch t3 := t2.Elem(); t3.Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3) + break + case reflect.Struct: + p.stype = t2.Elem() + p.isMarshaler = isMarshaler(t2) + p.isUnmarshaler = isUnmarshaler(t2) + if p.Wire == "bytes" { + p.enc = (*Buffer).enc_slice_struct_message + p.dec = (*Buffer).dec_slice_struct_message + p.size = size_slice_struct_message + } else { + p.enc = (*Buffer).enc_slice_struct_group + p.dec = (*Buffer).dec_slice_struct_group + p.size = size_slice_struct_group + } + } + case reflect.Slice: + switch t2.Elem().Kind() { + default: + fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem()) + break + case reflect.Uint8: + p.enc = (*Buffer).enc_slice_slice_byte + p.dec = (*Buffer).dec_slice_slice_byte + p.size = size_slice_slice_byte + } + } + + case reflect.Map: + p.enc = (*Buffer).enc_new_map + p.dec = (*Buffer).dec_new_map + p.size = size_new_map + + p.mtype = t1 + p.mkeyprop = &Properties{} + p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp) + p.mvalprop = &Properties{} + vtype := p.mtype.Elem() + if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice { + // The value type is not a message (*T) or bytes ([]byte), + // so we need encoders for the pointer to this type. + vtype = reflect.PtrTo(vtype) + } + p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp) + } + + // precalculate tag code + wire := p.WireType + if p.Packed { + wire = WireBytes + } + x := uint32(p.Tag)<<3 | uint32(wire) + i := 0 + for i = 0; x > 127; i++ { + p.tagbuf[i] = 0x80 | uint8(x&0x7F) + x >>= 7 + } + p.tagbuf[i] = uint8(x) + p.tagcode = p.tagbuf[0 : i+1] + + if p.stype != nil { + if lockGetProp { + p.sprop = GetProperties(p.stype) + } else { + p.sprop = getPropertiesLocked(p.stype) + } + } +} + +var ( + marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem() + unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem() +) + +// isMarshaler reports whether type t implements Marshaler. +func isMarshaler(t reflect.Type) bool { + // We're checking for (likely) pointer-receiver methods + // so if t is not a pointer, something is very wrong. + // The calls above only invoke isMarshaler on pointer types. + if t.Kind() != reflect.Ptr { + panic("proto: misuse of isMarshaler") + } + return t.Implements(marshalerType) +} + +// isUnmarshaler reports whether type t implements Unmarshaler. +func isUnmarshaler(t reflect.Type) bool { + // We're checking for (likely) pointer-receiver methods + // so if t is not a pointer, something is very wrong. + // The calls above only invoke isUnmarshaler on pointer types. + if t.Kind() != reflect.Ptr { + panic("proto: misuse of isUnmarshaler") + } + return t.Implements(unmarshalerType) +} + +// Init populates the properties from a protocol buffer struct tag. +func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) { + p.init(typ, name, tag, f, true) +} + +func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) { + // "bytes,49,opt,def=hello!" + p.Name = name + p.OrigName = name + if f != nil { + p.field = toField(f) + } + if tag == "" { + return + } + p.Parse(tag) + p.setEncAndDec(typ, f, lockGetProp) +} + +var ( + propertiesMu sync.RWMutex + propertiesMap = make(map[reflect.Type]*StructProperties) +) + +// GetProperties returns the list of properties for the type represented by t. +// t must represent a generated struct type of a protocol message. +func GetProperties(t reflect.Type) *StructProperties { + if t.Kind() != reflect.Struct { + panic("proto: type must have kind struct") + } + + // Most calls to GetProperties in a long-running program will be + // retrieving details for types we have seen before. + propertiesMu.RLock() + sprop, ok := propertiesMap[t] + propertiesMu.RUnlock() + if ok { + if collectStats { + stats.Chit++ + } + return sprop + } + + propertiesMu.Lock() + sprop = getPropertiesLocked(t) + propertiesMu.Unlock() + return sprop +} + +// getPropertiesLocked requires that propertiesMu is held. +func getPropertiesLocked(t reflect.Type) *StructProperties { + if prop, ok := propertiesMap[t]; ok { + if collectStats { + stats.Chit++ + } + return prop + } + if collectStats { + stats.Cmiss++ + } + + prop := new(StructProperties) + // in case of recursive protos, fill this in now. + propertiesMap[t] = prop + + // build properties + prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) || + reflect.PtrTo(t).Implements(extendableProtoV1Type) + prop.unrecField = invalidField + prop.Prop = make([]*Properties, t.NumField()) + prop.order = make([]int, t.NumField()) + + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + p := new(Properties) + name := f.Name + p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false) + + if f.Name == "XXX_InternalExtensions" { // special case + p.enc = (*Buffer).enc_exts + p.dec = nil // not needed + p.size = size_exts + } else if f.Name == "XXX_extensions" { // special case + p.enc = (*Buffer).enc_map + p.dec = nil // not needed + p.size = size_map + } else if f.Name == "XXX_unrecognized" { // special case + prop.unrecField = toField(&f) + } + oneof := f.Tag.Get("protobuf_oneof") // special case + if oneof != "" { + // Oneof fields don't use the traditional protobuf tag. + p.OrigName = oneof + } + prop.Prop[i] = p + prop.order[i] = i + if debug { + print(i, " ", f.Name, " ", t.String(), " ") + if p.Tag > 0 { + print(p.String()) + } + print("\n") + } + if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" { + fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]") + } + } + + // Re-order prop.order. + sort.Sort(prop) + + type oneofMessage interface { + XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{}) + } + if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok { + var oots []interface{} + prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs() + prop.stype = t + + // Interpret oneof metadata. + prop.OneofTypes = make(map[string]*OneofProperties) + for _, oot := range oots { + oop := &OneofProperties{ + Type: reflect.ValueOf(oot).Type(), // *T + Prop: new(Properties), + } + sft := oop.Type.Elem().Field(0) + oop.Prop.Name = sft.Name + oop.Prop.Parse(sft.Tag.Get("protobuf")) + // There will be exactly one interface field that + // this new value is assignable to. + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if f.Type.Kind() != reflect.Interface { + continue + } + if !oop.Type.AssignableTo(f.Type) { + continue + } + oop.Field = i + break + } + prop.OneofTypes[oop.Prop.OrigName] = oop + } + } + + // build required counts + // build tags + reqCount := 0 + prop.decoderOrigNames = make(map[string]int) + for i, p := range prop.Prop { + if strings.HasPrefix(p.Name, "XXX_") { + // Internal fields should not appear in tags/origNames maps. + // They are handled specially when encoding and decoding. + continue + } + if p.Required { + reqCount++ + } + prop.decoderTags.put(p.Tag, i) + prop.decoderOrigNames[p.OrigName] = i + } + prop.reqCount = reqCount + + return prop +} + +// Return the Properties object for the x[0]'th field of the structure. +func propByIndex(t reflect.Type, x []int) *Properties { + if len(x) != 1 { + fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t) + return nil + } + prop := GetProperties(t) + return prop.Prop[x[0]] +} + +// Get the address and type of a pointer to a struct from an interface. +func getbase(pb Message) (t reflect.Type, b structPointer, err error) { + if pb == nil { + err = ErrNil + return + } + // get the reflect type of the pointer to the struct. + t = reflect.TypeOf(pb) + // get the address of the struct. + value := reflect.ValueOf(pb) + b = toStructPointer(value) + return +} + +// A global registry of enum types. +// The generated code will register the generated maps by calling RegisterEnum. + +var enumValueMaps = make(map[string]map[string]int32) + +// RegisterEnum is called from the generated code to install the enum descriptor +// maps into the global table to aid parsing text format protocol buffers. +func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) { + if _, ok := enumValueMaps[typeName]; ok { + panic("proto: duplicate enum registered: " + typeName) + } + enumValueMaps[typeName] = valueMap +} + +// EnumValueMap returns the mapping from names to integers of the +// enum type enumType, or a nil if not found. +func EnumValueMap(enumType string) map[string]int32 { + return enumValueMaps[enumType] +} + +// A registry of all linked message types. +// The string is a fully-qualified proto name ("pkg.Message"). +var ( + protoTypes = make(map[string]reflect.Type) + revProtoTypes = make(map[reflect.Type]string) +) + +// RegisterType is called from generated code and maps from the fully qualified +// proto name to the type (pointer to struct) of the protocol buffer. +func RegisterType(x Message, name string) { + if _, ok := protoTypes[name]; ok { + // TODO: Some day, make this a panic. + log.Printf("proto: duplicate proto type registered: %s", name) + return + } + t := reflect.TypeOf(x) + protoTypes[name] = t + revProtoTypes[t] = name +} + +// MessageName returns the fully-qualified proto name for the given message type. +func MessageName(x Message) string { + type xname interface { + XXX_MessageName() string + } + if m, ok := x.(xname); ok { + return m.XXX_MessageName() + } + return revProtoTypes[reflect.TypeOf(x)] +} + +// MessageType returns the message type (pointer to struct) for a named message. +func MessageType(name string) reflect.Type { return protoTypes[name] } + +// A registry of all linked proto files. +var ( + protoFiles = make(map[string][]byte) // file name => fileDescriptor +) + +// RegisterFile is called from generated code and maps from the +// full file name of a .proto file to its compressed FileDescriptorProto. +func RegisterFile(filename string, fileDescriptor []byte) { + protoFiles[filename] = fileDescriptor +} + +// FileDescriptor returns the compressed FileDescriptorProto for a .proto file. +func FileDescriptor(filename string) []byte { return protoFiles[filename] } diff --git a/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go new file mode 100644 index 00000000..cc4d0489 --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/proto3_proto/proto3.pb.go @@ -0,0 +1,347 @@ +// Code generated by protoc-gen-go. +// source: proto3_proto/proto3.proto +// DO NOT EDIT! + +/* +Package proto3_proto is a generated protocol buffer package. + +It is generated from these files: + proto3_proto/proto3.proto + +It has these top-level messages: + Message + Nested + MessageWithMap + IntMap + IntMaps +*/ +package proto3_proto + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import google_protobuf "github.com/golang/protobuf/ptypes/any" +import testdata "github.com/golang/protobuf/proto/testdata" + +// 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 + +type Message_Humour int32 + +const ( + Message_UNKNOWN Message_Humour = 0 + Message_PUNS Message_Humour = 1 + Message_SLAPSTICK Message_Humour = 2 + Message_BILL_BAILEY Message_Humour = 3 +) + +var Message_Humour_name = map[int32]string{ + 0: "UNKNOWN", + 1: "PUNS", + 2: "SLAPSTICK", + 3: "BILL_BAILEY", +} +var Message_Humour_value = map[string]int32{ + "UNKNOWN": 0, + "PUNS": 1, + "SLAPSTICK": 2, + "BILL_BAILEY": 3, +} + +func (x Message_Humour) String() string { + return proto.EnumName(Message_Humour_name, int32(x)) +} +func (Message_Humour) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} } + +type Message struct { + Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Hilarity Message_Humour `protobuf:"varint,2,opt,name=hilarity,enum=proto3_proto.Message_Humour" json:"hilarity,omitempty"` + HeightInCm uint32 `protobuf:"varint,3,opt,name=height_in_cm,json=heightInCm" json:"height_in_cm,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + ResultCount int64 `protobuf:"varint,7,opt,name=result_count,json=resultCount" json:"result_count,omitempty"` + TrueScotsman bool `protobuf:"varint,8,opt,name=true_scotsman,json=trueScotsman" json:"true_scotsman,omitempty"` + Score float32 `protobuf:"fixed32,9,opt,name=score" json:"score,omitempty"` + Key []uint64 `protobuf:"varint,5,rep,packed,name=key" json:"key,omitempty"` + ShortKey []int32 `protobuf:"varint,19,rep,packed,name=short_key,json=shortKey" json:"short_key,omitempty"` + Nested *Nested `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"` + RFunny []Message_Humour `protobuf:"varint,16,rep,packed,name=r_funny,json=rFunny,enum=proto3_proto.Message_Humour" json:"r_funny,omitempty"` + Terrain map[string]*Nested `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Proto2Field *testdata.SubDefaults `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field" json:"proto2_field,omitempty"` + Proto2Value map[string]*testdata.SubDefaults `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value" json:"proto2_value,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + Anything *google_protobuf.Any `protobuf:"bytes,14,opt,name=anything" json:"anything,omitempty"` + ManyThings []*google_protobuf.Any `protobuf:"bytes,15,rep,name=many_things,json=manyThings" json:"many_things,omitempty"` + Submessage *Message `protobuf:"bytes,17,opt,name=submessage" json:"submessage,omitempty"` + Children []*Message `protobuf:"bytes,18,rep,name=children" json:"children,omitempty"` +} + +func (m *Message) Reset() { *m = Message{} } +func (m *Message) String() string { return proto.CompactTextString(m) } +func (*Message) ProtoMessage() {} +func (*Message) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +func (m *Message) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *Message) GetHilarity() Message_Humour { + if m != nil { + return m.Hilarity + } + return Message_UNKNOWN +} + +func (m *Message) GetHeightInCm() uint32 { + if m != nil { + return m.HeightInCm + } + return 0 +} + +func (m *Message) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *Message) GetResultCount() int64 { + if m != nil { + return m.ResultCount + } + return 0 +} + +func (m *Message) GetTrueScotsman() bool { + if m != nil { + return m.TrueScotsman + } + return false +} + +func (m *Message) GetScore() float32 { + if m != nil { + return m.Score + } + return 0 +} + +func (m *Message) GetKey() []uint64 { + if m != nil { + return m.Key + } + return nil +} + +func (m *Message) GetShortKey() []int32 { + if m != nil { + return m.ShortKey + } + return nil +} + +func (m *Message) GetNested() *Nested { + if m != nil { + return m.Nested + } + return nil +} + +func (m *Message) GetRFunny() []Message_Humour { + if m != nil { + return m.RFunny + } + return nil +} + +func (m *Message) GetTerrain() map[string]*Nested { + if m != nil { + return m.Terrain + } + return nil +} + +func (m *Message) GetProto2Field() *testdata.SubDefaults { + if m != nil { + return m.Proto2Field + } + return nil +} + +func (m *Message) GetProto2Value() map[string]*testdata.SubDefaults { + if m != nil { + return m.Proto2Value + } + return nil +} + +func (m *Message) GetAnything() *google_protobuf.Any { + if m != nil { + return m.Anything + } + return nil +} + +func (m *Message) GetManyThings() []*google_protobuf.Any { + if m != nil { + return m.ManyThings + } + return nil +} + +func (m *Message) GetSubmessage() *Message { + if m != nil { + return m.Submessage + } + return nil +} + +func (m *Message) GetChildren() []*Message { + if m != nil { + return m.Children + } + return nil +} + +type Nested struct { + Bunny string `protobuf:"bytes,1,opt,name=bunny" json:"bunny,omitempty"` + Cute bool `protobuf:"varint,2,opt,name=cute" json:"cute,omitempty"` +} + +func (m *Nested) Reset() { *m = Nested{} } +func (m *Nested) String() string { return proto.CompactTextString(m) } +func (*Nested) ProtoMessage() {} +func (*Nested) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +func (m *Nested) GetBunny() string { + if m != nil { + return m.Bunny + } + return "" +} + +func (m *Nested) GetCute() bool { + if m != nil { + return m.Cute + } + return false +} + +type MessageWithMap struct { + ByteMapping map[bool][]byte `protobuf:"bytes,1,rep,name=byte_mapping,json=byteMapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *MessageWithMap) Reset() { *m = MessageWithMap{} } +func (m *MessageWithMap) String() string { return proto.CompactTextString(m) } +func (*MessageWithMap) ProtoMessage() {} +func (*MessageWithMap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +func (m *MessageWithMap) GetByteMapping() map[bool][]byte { + if m != nil { + return m.ByteMapping + } + return nil +} + +type IntMap struct { + Rtt map[int32]int32 `protobuf:"bytes,1,rep,name=rtt" json:"rtt,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` +} + +func (m *IntMap) Reset() { *m = IntMap{} } +func (m *IntMap) String() string { return proto.CompactTextString(m) } +func (*IntMap) ProtoMessage() {} +func (*IntMap) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *IntMap) GetRtt() map[int32]int32 { + if m != nil { + return m.Rtt + } + return nil +} + +type IntMaps struct { + Maps []*IntMap `protobuf:"bytes,1,rep,name=maps" json:"maps,omitempty"` +} + +func (m *IntMaps) Reset() { *m = IntMaps{} } +func (m *IntMaps) String() string { return proto.CompactTextString(m) } +func (*IntMaps) ProtoMessage() {} +func (*IntMaps) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + +func (m *IntMaps) GetMaps() []*IntMap { + if m != nil { + return m.Maps + } + return nil +} + +func init() { + proto.RegisterType((*Message)(nil), "proto3_proto.Message") + proto.RegisterType((*Nested)(nil), "proto3_proto.Nested") + proto.RegisterType((*MessageWithMap)(nil), "proto3_proto.MessageWithMap") + proto.RegisterType((*IntMap)(nil), "proto3_proto.IntMap") + proto.RegisterType((*IntMaps)(nil), "proto3_proto.IntMaps") + proto.RegisterEnum("proto3_proto.Message_Humour", Message_Humour_name, Message_Humour_value) +} + +func init() { proto.RegisterFile("proto3_proto/proto3.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 733 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x84, 0x53, 0x6d, 0x6f, 0xf3, 0x34, + 0x14, 0x25, 0x4d, 0x5f, 0xd2, 0x9b, 0x74, 0x0b, 0x5e, 0x91, 0xbc, 0x02, 0x52, 0x28, 0x12, 0x8a, + 0x78, 0x49, 0xa1, 0xd3, 0xd0, 0x84, 0x10, 0x68, 0x1b, 0x9b, 0xa8, 0xd6, 0x95, 0xca, 0xdd, 0x98, + 0xf8, 0x14, 0xa5, 0xad, 0xdb, 0x46, 0x34, 0x4e, 0x49, 0x1c, 0xa4, 0xfc, 0x1d, 0xfe, 0x28, 0x8f, + 0x6c, 0xa7, 0x5d, 0x36, 0x65, 0xcf, 0xf3, 0x29, 0xf6, 0xf1, 0xb9, 0xf7, 0x9c, 0x1c, 0x5f, 0xc3, + 0xe9, 0x2e, 0x89, 0x79, 0x7c, 0xe6, 0xcb, 0xcf, 0x40, 0x6d, 0x3c, 0xf9, 0x41, 0x56, 0xf9, 0xa8, + 0x77, 0xba, 0x8e, 0xe3, 0xf5, 0x96, 0x2a, 0xca, 0x3c, 0x5b, 0x0d, 0x02, 0x96, 0x2b, 0x62, 0xef, + 0x84, 0xd3, 0x94, 0x2f, 0x03, 0x1e, 0x0c, 0xc4, 0x42, 0x81, 0xfd, 0xff, 0x5b, 0xd0, 0xba, 0xa7, + 0x69, 0x1a, 0xac, 0x29, 0x42, 0x50, 0x67, 0x41, 0x44, 0xb1, 0xe6, 0x68, 0x6e, 0x9b, 0xc8, 0x35, + 0xba, 0x00, 0x63, 0x13, 0x6e, 0x83, 0x24, 0xe4, 0x39, 0xae, 0x39, 0x9a, 0x7b, 0x34, 0xfc, 0xcc, + 0x2b, 0x0b, 0x7a, 0x45, 0xb1, 0xf7, 0x7b, 0x16, 0xc5, 0x59, 0x42, 0x0e, 0x6c, 0xe4, 0x80, 0xb5, + 0xa1, 0xe1, 0x7a, 0xc3, 0xfd, 0x90, 0xf9, 0x8b, 0x08, 0xeb, 0x8e, 0xe6, 0x76, 0x08, 0x28, 0x6c, + 0xc4, 0xae, 0x23, 0xa1, 0x27, 0xec, 0xe0, 0xba, 0xa3, 0xb9, 0x16, 0x91, 0x6b, 0xf4, 0x05, 0x58, + 0x09, 0x4d, 0xb3, 0x2d, 0xf7, 0x17, 0x71, 0xc6, 0x38, 0x6e, 0x39, 0x9a, 0xab, 0x13, 0x53, 0x61, + 0xd7, 0x02, 0x42, 0x5f, 0x42, 0x87, 0x27, 0x19, 0xf5, 0xd3, 0x45, 0xcc, 0xd3, 0x28, 0x60, 0xd8, + 0x70, 0x34, 0xd7, 0x20, 0x96, 0x00, 0x67, 0x05, 0x86, 0xba, 0xd0, 0x48, 0x17, 0x71, 0x42, 0x71, + 0xdb, 0xd1, 0xdc, 0x1a, 0x51, 0x1b, 0x64, 0x83, 0xfe, 0x37, 0xcd, 0x71, 0xc3, 0xd1, 0xdd, 0x3a, + 0x11, 0x4b, 0xf4, 0x29, 0xb4, 0xd3, 0x4d, 0x9c, 0x70, 0x5f, 0xe0, 0x27, 0x8e, 0xee, 0x36, 0x88, + 0x21, 0x81, 0x3b, 0x9a, 0xa3, 0x6f, 0xa1, 0xc9, 0x68, 0xca, 0xe9, 0x12, 0x37, 0x1d, 0xcd, 0x35, + 0x87, 0xdd, 0x97, 0xbf, 0x3e, 0x91, 0x67, 0xa4, 0xe0, 0xa0, 0x73, 0x68, 0x25, 0xfe, 0x2a, 0x63, + 0x2c, 0xc7, 0xb6, 0xa3, 0x7f, 0x30, 0xa9, 0x66, 0x72, 0x2b, 0xb8, 0xe8, 0x67, 0x68, 0x71, 0x9a, + 0x24, 0x41, 0xc8, 0x30, 0x38, 0xba, 0x6b, 0x0e, 0xfb, 0xd5, 0x65, 0x0f, 0x8a, 0x74, 0xc3, 0x78, + 0x92, 0x93, 0x7d, 0x09, 0xba, 0x00, 0x75, 0xff, 0x43, 0x7f, 0x15, 0xd2, 0xed, 0x12, 0x9b, 0xd2, + 0xe8, 0x27, 0xde, 0xfe, 0xae, 0xbd, 0x59, 0x36, 0xff, 0x8d, 0xae, 0x82, 0x6c, 0xcb, 0x53, 0x62, + 0x2a, 0xea, 0xad, 0x60, 0xa2, 0xd1, 0xa1, 0xf2, 0xdf, 0x60, 0x9b, 0x51, 0xdc, 0x91, 0xe2, 0x5f, + 0x55, 0x8b, 0x4f, 0x25, 0xf3, 0x4f, 0x41, 0x54, 0x06, 0x8a, 0x56, 0x12, 0x41, 0xdf, 0x83, 0x11, + 0xb0, 0x9c, 0x6f, 0x42, 0xb6, 0xc6, 0x47, 0x45, 0x52, 0x6a, 0x0e, 0xbd, 0xfd, 0x1c, 0x7a, 0x97, + 0x2c, 0x27, 0x07, 0x16, 0x3a, 0x07, 0x33, 0x0a, 0x58, 0xee, 0xcb, 0x5d, 0x8a, 0x8f, 0xa5, 0x76, + 0x75, 0x11, 0x08, 0xe2, 0x83, 0xe4, 0xa1, 0x73, 0x80, 0x34, 0x9b, 0x47, 0xca, 0x14, 0xfe, 0xb8, + 0xf8, 0xd7, 0x2a, 0xc7, 0xa4, 0x44, 0x44, 0x3f, 0x80, 0xb1, 0xd8, 0x84, 0xdb, 0x65, 0x42, 0x19, + 0x46, 0x52, 0xea, 0x8d, 0xa2, 0x03, 0xad, 0x37, 0x05, 0xab, 0x1c, 0xf8, 0x7e, 0x72, 0xd4, 0xd3, + 0x90, 0x93, 0xf3, 0x35, 0x34, 0x54, 0x70, 0xb5, 0xf7, 0xcc, 0x86, 0xa2, 0xfc, 0x54, 0xbb, 0xd0, + 0x7a, 0x8f, 0x60, 0xbf, 0x4e, 0xb1, 0xa2, 0xeb, 0x37, 0x2f, 0xbb, 0xbe, 0x71, 0x91, 0xcf, 0x6d, + 0xfb, 0xbf, 0x42, 0x53, 0x0d, 0x14, 0x32, 0xa1, 0xf5, 0x38, 0xb9, 0x9b, 0xfc, 0xf1, 0x34, 0xb1, + 0x3f, 0x42, 0x06, 0xd4, 0xa7, 0x8f, 0x93, 0x99, 0xad, 0xa1, 0x0e, 0xb4, 0x67, 0xe3, 0xcb, 0xe9, + 0xec, 0x61, 0x74, 0x7d, 0x67, 0xd7, 0xd0, 0x31, 0x98, 0x57, 0xa3, 0xf1, 0xd8, 0xbf, 0xba, 0x1c, + 0x8d, 0x6f, 0xfe, 0xb2, 0xf5, 0xfe, 0x10, 0x9a, 0xca, 0xac, 0x78, 0x33, 0x73, 0x39, 0xbe, 0xca, + 0x8f, 0xda, 0x88, 0x57, 0xba, 0xc8, 0xb8, 0x32, 0x64, 0x10, 0xb9, 0xee, 0xff, 0xa7, 0xc1, 0x51, + 0x91, 0xd9, 0x53, 0xc8, 0x37, 0xf7, 0xc1, 0x0e, 0x4d, 0xc1, 0x9a, 0xe7, 0x9c, 0xfa, 0x51, 0xb0, + 0xdb, 0x89, 0x39, 0xd0, 0x64, 0xce, 0xdf, 0x55, 0xe6, 0x5c, 0xd4, 0x78, 0x57, 0x39, 0xa7, 0xf7, + 0x8a, 0x5f, 0x4c, 0xd5, 0xfc, 0x19, 0xe9, 0xfd, 0x02, 0xf6, 0x6b, 0x42, 0x39, 0x30, 0x43, 0x05, + 0xd6, 0x2d, 0x07, 0x66, 0x95, 0x93, 0xf9, 0x07, 0x9a, 0x23, 0xc6, 0x85, 0xb7, 0x01, 0xe8, 0x09, + 0xe7, 0x85, 0xa5, 0xcf, 0x5f, 0x5a, 0x52, 0x14, 0x8f, 0x70, 0xae, 0x2c, 0x08, 0x66, 0xef, 0x47, + 0x30, 0xf6, 0x40, 0x59, 0xb2, 0x51, 0x21, 0xd9, 0x28, 0x4b, 0x9e, 0x41, 0x4b, 0xf5, 0x4b, 0x91, + 0x0b, 0xf5, 0x28, 0xd8, 0xa5, 0x85, 0x68, 0xb7, 0x4a, 0x94, 0x48, 0xc6, 0xbc, 0xa9, 0x8e, 0xde, + 0x05, 0x00, 0x00, 0xff, 0xff, 0x75, 0x38, 0xad, 0x84, 0xe4, 0x05, 0x00, 0x00, +} diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.go new file mode 100644 index 00000000..965876bf --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/text.go @@ -0,0 +1,854 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +// Functions for writing the text protocol buffer format. + +import ( + "bufio" + "bytes" + "encoding" + "errors" + "fmt" + "io" + "log" + "math" + "reflect" + "sort" + "strings" +) + +var ( + newline = []byte("\n") + spaces = []byte(" ") + gtNewline = []byte(">\n") + endBraceNewline = []byte("}\n") + backslashN = []byte{'\\', 'n'} + backslashR = []byte{'\\', 'r'} + backslashT = []byte{'\\', 't'} + backslashDQ = []byte{'\\', '"'} + backslashBS = []byte{'\\', '\\'} + posInf = []byte("inf") + negInf = []byte("-inf") + nan = []byte("nan") +) + +type writer interface { + io.Writer + WriteByte(byte) error +} + +// textWriter is an io.Writer that tracks its indentation level. +type textWriter struct { + ind int + complete bool // if the current position is a complete line + compact bool // whether to write out as a one-liner + w writer +} + +func (w *textWriter) WriteString(s string) (n int, err error) { + if !strings.Contains(s, "\n") { + if !w.compact && w.complete { + w.writeIndent() + } + w.complete = false + return io.WriteString(w.w, s) + } + // WriteString is typically called without newlines, so this + // codepath and its copy are rare. We copy to avoid + // duplicating all of Write's logic here. + return w.Write([]byte(s)) +} + +func (w *textWriter) Write(p []byte) (n int, err error) { + newlines := bytes.Count(p, newline) + if newlines == 0 { + if !w.compact && w.complete { + w.writeIndent() + } + n, err = w.w.Write(p) + w.complete = false + return n, err + } + + frags := bytes.SplitN(p, newline, newlines+1) + if w.compact { + for i, frag := range frags { + if i > 0 { + if err := w.w.WriteByte(' '); err != nil { + return n, err + } + n++ + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + } + return n, nil + } + + for i, frag := range frags { + if w.complete { + w.writeIndent() + } + nn, err := w.w.Write(frag) + n += nn + if err != nil { + return n, err + } + if i+1 < len(frags) { + if err := w.w.WriteByte('\n'); err != nil { + return n, err + } + n++ + } + } + w.complete = len(frags[len(frags)-1]) == 0 + return n, nil +} + +func (w *textWriter) WriteByte(c byte) error { + if w.compact && c == '\n' { + c = ' ' + } + if !w.compact && w.complete { + w.writeIndent() + } + err := w.w.WriteByte(c) + w.complete = c == '\n' + return err +} + +func (w *textWriter) indent() { w.ind++ } + +func (w *textWriter) unindent() { + if w.ind == 0 { + log.Print("proto: textWriter unindented too far") + return + } + w.ind-- +} + +func writeName(w *textWriter, props *Properties) error { + if _, err := w.WriteString(props.OrigName); err != nil { + return err + } + if props.Wire != "group" { + return w.WriteByte(':') + } + return nil +} + +// raw is the interface satisfied by RawMessage. +type raw interface { + Bytes() []byte +} + +func requiresQuotes(u string) bool { + // When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted. + for _, ch := range u { + switch { + case ch == '.' || ch == '/' || ch == '_': + continue + case '0' <= ch && ch <= '9': + continue + case 'A' <= ch && ch <= 'Z': + continue + case 'a' <= ch && ch <= 'z': + continue + default: + return true + } + } + return false +} + +// isAny reports whether sv is a google.protobuf.Any message +func isAny(sv reflect.Value) bool { + type wkt interface { + XXX_WellKnownType() string + } + t, ok := sv.Addr().Interface().(wkt) + return ok && t.XXX_WellKnownType() == "Any" +} + +// writeProto3Any writes an expanded google.protobuf.Any message. +// +// It returns (false, nil) if sv value can't be unmarshaled (e.g. because +// required messages are not linked in). +// +// It returns (true, error) when sv was written in expanded format or an error +// was encountered. +func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) { + turl := sv.FieldByName("TypeUrl") + val := sv.FieldByName("Value") + if !turl.IsValid() || !val.IsValid() { + return true, errors.New("proto: invalid google.protobuf.Any message") + } + + b, ok := val.Interface().([]byte) + if !ok { + return true, errors.New("proto: invalid google.protobuf.Any message") + } + + parts := strings.Split(turl.String(), "/") + mt := MessageType(parts[len(parts)-1]) + if mt == nil { + return false, nil + } + m := reflect.New(mt.Elem()) + if err := Unmarshal(b, m.Interface().(Message)); err != nil { + return false, nil + } + w.Write([]byte("[")) + u := turl.String() + if requiresQuotes(u) { + writeString(w, u) + } else { + w.Write([]byte(u)) + } + if w.compact { + w.Write([]byte("]:<")) + } else { + w.Write([]byte("]: <\n")) + w.ind++ + } + if err := tm.writeStruct(w, m.Elem()); err != nil { + return true, err + } + if w.compact { + w.Write([]byte("> ")) + } else { + w.ind-- + w.Write([]byte(">\n")) + } + return true, nil +} + +func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error { + if tm.ExpandAny && isAny(sv) { + if canExpand, err := tm.writeProto3Any(w, sv); canExpand { + return err + } + } + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < sv.NumField(); i++ { + fv := sv.Field(i) + props := sprops.Prop[i] + name := st.Field(i).Name + + if strings.HasPrefix(name, "XXX_") { + // There are two XXX_ fields: + // XXX_unrecognized []byte + // XXX_extensions map[int32]proto.Extension + // The first is handled here; + // the second is handled at the bottom of this function. + if name == "XXX_unrecognized" && !fv.IsNil() { + if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Field not filled in. This could be an optional field or + // a required field that wasn't filled in. Either way, there + // isn't anything we can show for it. + continue + } + if fv.Kind() == reflect.Slice && fv.IsNil() { + // Repeated field that is empty, or a bytes field that is unused. + continue + } + + if props.Repeated && fv.Kind() == reflect.Slice { + // Repeated field. + for j := 0; j < fv.Len(); j++ { + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + v := fv.Index(j) + if v.Kind() == reflect.Ptr && v.IsNil() { + // A nil message in a repeated field is not valid, + // but we can handle that more gracefully than panicking. + if _, err := w.Write([]byte("\n")); err != nil { + return err + } + continue + } + if err := tm.writeAny(w, v, props); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if fv.Kind() == reflect.Map { + // Map fields are rendered as a repeated struct with key/value fields. + keys := fv.MapKeys() + sort.Sort(mapKeys(keys)) + for _, key := range keys { + val := fv.MapIndex(key) + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + // open struct + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + // key + if _, err := w.WriteString("key:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := tm.writeAny(w, key, props.mkeyprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + // nil values aren't legal, but we can avoid panicking because of them. + if val.Kind() != reflect.Ptr || !val.IsNil() { + // value + if _, err := w.WriteString("value:"); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := tm.writeAny(w, val, props.mvalprop); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + // close struct + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + } + continue + } + if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 { + // empty bytes field + continue + } + if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice { + // proto3 non-repeated scalar field; skip if zero value + if isProto3Zero(fv) { + continue + } + } + + if fv.Kind() == reflect.Interface { + // Check if it is a oneof. + if st.Field(i).Tag.Get("protobuf_oneof") != "" { + // fv is nil, or holds a pointer to generated struct. + // That generated struct has exactly one field, + // which has a protobuf struct tag. + if fv.IsNil() { + continue + } + inner := fv.Elem().Elem() // interface -> *T -> T + tag := inner.Type().Field(0).Tag.Get("protobuf") + props = new(Properties) // Overwrite the outer props var, but not its pointee. + props.Parse(tag) + // Write the value in the oneof, not the oneof itself. + fv = inner.Field(0) + + // Special case to cope with malformed messages gracefully: + // If the value in the oneof is a nil pointer, don't panic + // in writeAny. + if fv.Kind() == reflect.Ptr && fv.IsNil() { + // Use errors.New so writeAny won't render quotes. + msg := errors.New("/* nil */") + fv = reflect.ValueOf(&msg).Elem() + } + } + } + + if err := writeName(w, props); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if b, ok := fv.Interface().(raw); ok { + if err := writeRaw(w, b.Bytes()); err != nil { + return err + } + continue + } + + // Enums have a String method, so writeAny will work fine. + if err := tm.writeAny(w, fv, props); err != nil { + return err + } + + if err := w.WriteByte('\n'); err != nil { + return err + } + } + + // Extensions (the XXX_extensions field). + pv := sv.Addr() + if _, ok := extendable(pv.Interface()); ok { + if err := tm.writeExtensions(w, pv); err != nil { + return err + } + } + + return nil +} + +// writeRaw writes an uninterpreted raw message. +func writeRaw(w *textWriter, b []byte) error { + if err := w.WriteByte('<'); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if err := writeUnknownStruct(w, b); err != nil { + return err + } + w.unindent() + if err := w.WriteByte('>'); err != nil { + return err + } + return nil +} + +// writeAny writes an arbitrary field. +func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error { + v = reflect.Indirect(v) + + // Floats have special cases. + if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 { + x := v.Float() + var b []byte + switch { + case math.IsInf(x, 1): + b = posInf + case math.IsInf(x, -1): + b = negInf + case math.IsNaN(x): + b = nan + } + if b != nil { + _, err := w.Write(b) + return err + } + // Other values are handled below. + } + + // We don't attempt to serialise every possible value type; only those + // that can occur in protocol buffers. + switch v.Kind() { + case reflect.Slice: + // Should only be a []byte; repeated fields are handled in writeStruct. + if err := writeString(w, string(v.Bytes())); err != nil { + return err + } + case reflect.String: + if err := writeString(w, v.String()); err != nil { + return err + } + case reflect.Struct: + // Required/optional group/message. + var bra, ket byte = '<', '>' + if props != nil && props.Wire == "group" { + bra, ket = '{', '}' + } + if err := w.WriteByte(bra); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte('\n'); err != nil { + return err + } + } + w.indent() + if etm, ok := v.Interface().(encoding.TextMarshaler); ok { + text, err := etm.MarshalText() + if err != nil { + return err + } + if _, err = w.Write(text); err != nil { + return err + } + } else if err := tm.writeStruct(w, v); err != nil { + return err + } + w.unindent() + if err := w.WriteByte(ket); err != nil { + return err + } + default: + _, err := fmt.Fprint(w, v.Interface()) + return err + } + return nil +} + +// equivalent to C's isprint. +func isprint(c byte) bool { + return c >= 0x20 && c < 0x7f +} + +// writeString writes a string in the protocol buffer text format. +// It is similar to strconv.Quote except we don't use Go escape sequences, +// we treat the string as a byte sequence, and we use octal escapes. +// These differences are to maintain interoperability with the other +// languages' implementations of the text format. +func writeString(w *textWriter, s string) error { + // use WriteByte here to get any needed indent + if err := w.WriteByte('"'); err != nil { + return err + } + // Loop over the bytes, not the runes. + for i := 0; i < len(s); i++ { + var err error + // Divergence from C++: we don't escape apostrophes. + // There's no need to escape them, and the C++ parser + // copes with a naked apostrophe. + switch c := s[i]; c { + case '\n': + _, err = w.w.Write(backslashN) + case '\r': + _, err = w.w.Write(backslashR) + case '\t': + _, err = w.w.Write(backslashT) + case '"': + _, err = w.w.Write(backslashDQ) + case '\\': + _, err = w.w.Write(backslashBS) + default: + if isprint(c) { + err = w.w.WriteByte(c) + } else { + _, err = fmt.Fprintf(w.w, "\\%03o", c) + } + } + if err != nil { + return err + } + } + return w.WriteByte('"') +} + +func writeUnknownStruct(w *textWriter, data []byte) (err error) { + if !w.compact { + if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil { + return err + } + } + b := NewBuffer(data) + for b.index < len(b.buf) { + x, err := b.DecodeVarint() + if err != nil { + _, err := fmt.Fprintf(w, "/* %v */\n", err) + return err + } + wire, tag := x&7, x>>3 + if wire == WireEndGroup { + w.unindent() + if _, err := w.Write(endBraceNewline); err != nil { + return err + } + continue + } + if _, err := fmt.Fprint(w, tag); err != nil { + return err + } + if wire != WireStartGroup { + if err := w.WriteByte(':'); err != nil { + return err + } + } + if !w.compact || wire == WireStartGroup { + if err := w.WriteByte(' '); err != nil { + return err + } + } + switch wire { + case WireBytes: + buf, e := b.DecodeRawBytes(false) + if e == nil { + _, err = fmt.Fprintf(w, "%q", buf) + } else { + _, err = fmt.Fprintf(w, "/* %v */", e) + } + case WireFixed32: + x, err = b.DecodeFixed32() + err = writeUnknownInt(w, x, err) + case WireFixed64: + x, err = b.DecodeFixed64() + err = writeUnknownInt(w, x, err) + case WireStartGroup: + err = w.WriteByte('{') + w.indent() + case WireVarint: + x, err = b.DecodeVarint() + err = writeUnknownInt(w, x, err) + default: + _, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire) + } + if err != nil { + return err + } + if err = w.WriteByte('\n'); err != nil { + return err + } + } + return nil +} + +func writeUnknownInt(w *textWriter, x uint64, err error) error { + if err == nil { + _, err = fmt.Fprint(w, x) + } else { + _, err = fmt.Fprintf(w, "/* %v */", err) + } + return err +} + +type int32Slice []int32 + +func (s int32Slice) Len() int { return len(s) } +func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } +func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +// writeExtensions writes all the extensions in pv. +// pv is assumed to be a pointer to a protocol message struct that is extendable. +func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error { + emap := extensionMaps[pv.Type().Elem()] + ep, _ := extendable(pv.Interface()) + + // Order the extensions by ID. + // This isn't strictly necessary, but it will give us + // canonical output, which will also make testing easier. + m, mu := ep.extensionsRead() + if m == nil { + return nil + } + mu.Lock() + ids := make([]int32, 0, len(m)) + for id := range m { + ids = append(ids, id) + } + sort.Sort(int32Slice(ids)) + mu.Unlock() + + for _, extNum := range ids { + ext := m[extNum] + var desc *ExtensionDesc + if emap != nil { + desc = emap[extNum] + } + if desc == nil { + // Unknown extension. + if err := writeUnknownStruct(w, ext.enc); err != nil { + return err + } + continue + } + + pb, err := GetExtension(ep, desc) + if err != nil { + return fmt.Errorf("failed getting extension: %v", err) + } + + // Repeated extensions will appear as a slice. + if !desc.repeated() { + if err := tm.writeExtension(w, desc.Name, pb); err != nil { + return err + } + } else { + v := reflect.ValueOf(pb) + for i := 0; i < v.Len(); i++ { + if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { + return err + } + } + } + } + return nil +} + +func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error { + if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil { + return err + } + if !w.compact { + if err := w.WriteByte(' '); err != nil { + return err + } + } + if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil { + return err + } + if err := w.WriteByte('\n'); err != nil { + return err + } + return nil +} + +func (w *textWriter) writeIndent() { + if !w.complete { + return + } + remain := w.ind * 2 + for remain > 0 { + n := remain + if n > len(spaces) { + n = len(spaces) + } + w.w.Write(spaces[:n]) + remain -= n + } + w.complete = false +} + +// TextMarshaler is a configurable text format marshaler. +type TextMarshaler struct { + Compact bool // use compact text format (one line). + ExpandAny bool // expand google.protobuf.Any messages of known types +} + +// Marshal writes a given protocol buffer in text format. +// The only errors returned are from w. +func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error { + val := reflect.ValueOf(pb) + if pb == nil || val.IsNil() { + w.Write([]byte("")) + return nil + } + var bw *bufio.Writer + ww, ok := w.(writer) + if !ok { + bw = bufio.NewWriter(w) + ww = bw + } + aw := &textWriter{ + w: ww, + complete: true, + compact: tm.Compact, + } + + if etm, ok := pb.(encoding.TextMarshaler); ok { + text, err := etm.MarshalText() + if err != nil { + return err + } + if _, err = aw.Write(text); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil + } + // Dereference the received pointer so we don't have outer < and >. + v := reflect.Indirect(val) + if err := tm.writeStruct(aw, v); err != nil { + return err + } + if bw != nil { + return bw.Flush() + } + return nil +} + +// Text is the same as Marshal, but returns the string directly. +func (tm *TextMarshaler) Text(pb Message) string { + var buf bytes.Buffer + tm.Marshal(&buf, pb) + return buf.String() +} + +var ( + defaultTextMarshaler = TextMarshaler{} + compactTextMarshaler = TextMarshaler{Compact: true} +) + +// TODO: consider removing some of the Marshal functions below. + +// MarshalText writes a given protocol buffer in text format. +// The only errors returned are from w. +func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) } + +// MarshalTextString is the same as MarshalText, but returns the string directly. +func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) } + +// CompactText writes a given protocol buffer in compact text format (one line). +func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) } + +// CompactTextString is the same as CompactText, but returns the string directly. +func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) } diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.go new file mode 100644 index 00000000..61f83c1e --- /dev/null +++ b/vendor/github.com/golang/protobuf/proto/text_parser.go @@ -0,0 +1,895 @@ +// Go support for Protocol Buffers - Google's data interchange format +// +// Copyright 2010 The Go Authors. All rights reserved. +// https://github.com/golang/protobuf +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +package proto + +// Functions for parsing the Text protocol buffer format. +// TODO: message sets. + +import ( + "encoding" + "errors" + "fmt" + "reflect" + "strconv" + "strings" + "unicode/utf8" +) + +// Error string emitted when deserializing Any and fields are already set +const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set" + +type ParseError struct { + Message string + Line int // 1-based line number + Offset int // 0-based byte offset from start of input +} + +func (p *ParseError) Error() string { + if p.Line == 1 { + // show offset only for first line + return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message) + } + return fmt.Sprintf("line %d: %v", p.Line, p.Message) +} + +type token struct { + value string + err *ParseError + line int // line number + offset int // byte number from start of input, not start of line + unquoted string // the unquoted version of value, if it was a quoted string +} + +func (t *token) String() string { + if t.err == nil { + return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset) + } + return fmt.Sprintf("parse error: %v", t.err) +} + +type textParser struct { + s string // remaining input + done bool // whether the parsing is finished (success or error) + backed bool // whether back() was called + offset, line int + cur token +} + +func newTextParser(s string) *textParser { + p := new(textParser) + p.s = s + p.line = 1 + p.cur.line = 1 + return p +} + +func (p *textParser) errorf(format string, a ...interface{}) *ParseError { + pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} + p.cur.err = pe + p.done = true + return pe +} + +// Numbers and identifiers are matched by [-+._A-Za-z0-9] +func isIdentOrNumberChar(c byte) bool { + switch { + case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': + return true + case '0' <= c && c <= '9': + return true + } + switch c { + case '-', '+', '.', '_': + return true + } + return false +} + +func isWhitespace(c byte) bool { + switch c { + case ' ', '\t', '\n', '\r': + return true + } + return false +} + +func isQuote(c byte) bool { + switch c { + case '"', '\'': + return true + } + return false +} + +func (p *textParser) skipWhitespace() { + i := 0 + for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { + if p.s[i] == '#' { + // comment; skip to end of line or input + for i < len(p.s) && p.s[i] != '\n' { + i++ + } + if i == len(p.s) { + break + } + } + if p.s[i] == '\n' { + p.line++ + } + i++ + } + p.offset += i + p.s = p.s[i:len(p.s)] + if len(p.s) == 0 { + p.done = true + } +} + +func (p *textParser) advance() { + // Skip whitespace + p.skipWhitespace() + if p.done { + return + } + + // Start of non-whitespace + p.cur.err = nil + p.cur.offset, p.cur.line = p.offset, p.line + p.cur.unquoted = "" + switch p.s[0] { + case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/': + // Single symbol + p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] + case '"', '\'': + // Quoted string + i := 1 + for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { + if p.s[i] == '\\' && i+1 < len(p.s) { + // skip escaped char + i++ + } + i++ + } + if i >= len(p.s) || p.s[i] != p.s[0] { + p.errorf("unmatched quote") + return + } + unq, err := unquoteC(p.s[1:i], rune(p.s[0])) + if err != nil { + p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) + return + } + p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] + p.cur.unquoted = unq + default: + i := 0 + for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { + i++ + } + if i == 0 { + p.errorf("unexpected byte %#x", p.s[0]) + return + } + p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] + } + p.offset += len(p.cur.value) +} + +var ( + errBadUTF8 = errors.New("proto: bad UTF-8") + errBadHex = errors.New("proto: bad hexadecimal") +) + +func unquoteC(s string, quote rune) (string, error) { + // This is based on C++'s tokenizer.cc. + // Despite its name, this is *not* parsing C syntax. + // For instance, "\0" is an invalid quoted string. + + // Avoid allocation in trivial cases. + simple := true + for _, r := range s { + if r == '\\' || r == quote { + simple = false + break + } + } + if simple { + return s, nil + } + + buf := make([]byte, 0, 3*len(s)/2) + for len(s) > 0 { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", errBadUTF8 + } + s = s[n:] + if r != '\\' { + if r < utf8.RuneSelf { + buf = append(buf, byte(r)) + } else { + buf = append(buf, string(r)...) + } + continue + } + + ch, tail, err := unescape(s) + if err != nil { + return "", err + } + buf = append(buf, ch...) + s = tail + } + return string(buf), nil +} + +func unescape(s string) (ch string, tail string, err error) { + r, n := utf8.DecodeRuneInString(s) + if r == utf8.RuneError && n == 1 { + return "", "", errBadUTF8 + } + s = s[n:] + switch r { + case 'a': + return "\a", s, nil + case 'b': + return "\b", s, nil + case 'f': + return "\f", s, nil + case 'n': + return "\n", s, nil + case 'r': + return "\r", s, nil + case 't': + return "\t", s, nil + case 'v': + return "\v", s, nil + case '?': + return "?", s, nil // trigraph workaround + case '\'', '"', '\\': + return string(r), s, nil + case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X': + if len(s) < 2 { + return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) + } + base := 8 + ss := s[:2] + s = s[2:] + if r == 'x' || r == 'X' { + base = 16 + } else { + ss = string(r) + ss + } + i, err := strconv.ParseUint(ss, base, 8) + if err != nil { + return "", "", err + } + return string([]byte{byte(i)}), s, nil + case 'u', 'U': + n := 4 + if r == 'U' { + n = 8 + } + if len(s) < n { + return "", "", fmt.Errorf(`\%c requires %d digits`, r, n) + } + + bs := make([]byte, n/2) + for i := 0; i < n; i += 2 { + a, ok1 := unhex(s[i]) + b, ok2 := unhex(s[i+1]) + if !ok1 || !ok2 { + return "", "", errBadHex + } + bs[i/2] = a<<4 | b + } + s = s[n:] + return string(bs), s, nil + } + return "", "", fmt.Errorf(`unknown escape \%c`, r) +} + +// Adapted from src/pkg/strconv/quote.go. +func unhex(b byte) (v byte, ok bool) { + switch { + case '0' <= b && b <= '9': + return b - '0', true + case 'a' <= b && b <= 'f': + return b - 'a' + 10, true + case 'A' <= b && b <= 'F': + return b - 'A' + 10, true + } + return 0, false +} + +// Back off the parser by one token. Can only be done between calls to next(). +// It makes the next advance() a no-op. +func (p *textParser) back() { p.backed = true } + +// Advances the parser and returns the new current token. +func (p *textParser) next() *token { + if p.backed || p.done { + p.backed = false + return &p.cur + } + p.advance() + if p.done { + p.cur.value = "" + } else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { + // Look for multiple quoted strings separated by whitespace, + // and concatenate them. + cat := p.cur + for { + p.skipWhitespace() + if p.done || !isQuote(p.s[0]) { + break + } + p.advance() + if p.cur.err != nil { + return &p.cur + } + cat.value += " " + p.cur.value + cat.unquoted += p.cur.unquoted + } + p.done = false // parser may have seen EOF, but we want to return cat + p.cur = cat + } + return &p.cur +} + +func (p *textParser) consumeToken(s string) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != s { + p.back() + return p.errorf("expected %q, found %q", s, tok.value) + } + return nil +} + +// Return a RequiredNotSetError indicating which required field was not set. +func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError { + st := sv.Type() + sprops := GetProperties(st) + for i := 0; i < st.NumField(); i++ { + if !isNil(sv.Field(i)) { + continue + } + + props := sprops.Prop[i] + if props.Required { + return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)} + } + } + return &RequiredNotSetError{fmt.Sprintf("%v.", st)} // should not happen +} + +// Returns the index in the struct for the named field, as well as the parsed tag properties. +func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) { + i, ok := sprops.decoderOrigNames[name] + if ok { + return i, sprops.Prop[i], true + } + return -1, nil, false +} + +// Consume a ':' from the input stream (if the next token is a colon), +// returning an error if a colon is needed but not present. +func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ":" { + // Colon is optional when the field is a group or message. + needColon := true + switch props.Wire { + case "group": + needColon = false + case "bytes": + // A "bytes" field is either a message, a string, or a repeated field; + // those three become *T, *string and []T respectively, so we can check for + // this field being a pointer to a non-string. + if typ.Kind() == reflect.Ptr { + // *T or *string + if typ.Elem().Kind() == reflect.String { + break + } + } else if typ.Kind() == reflect.Slice { + // []T or []*T + if typ.Elem().Kind() != reflect.Ptr { + break + } + } else if typ.Kind() == reflect.String { + // The proto3 exception is for a string field, + // which requires a colon. + break + } + needColon = false + } + if needColon { + return p.errorf("expected ':', found %q", tok.value) + } + p.back() + } + return nil +} + +func (p *textParser) readStruct(sv reflect.Value, terminator string) error { + st := sv.Type() + sprops := GetProperties(st) + reqCount := sprops.reqCount + var reqFieldErr error + fieldSet := make(map[string]bool) + // A struct is a sequence of "name: value", terminated by one of + // '>' or '}', or the end of the input. A name may also be + // "[extension]" or "[type/url]". + // + // The whole struct can also be an expanded Any message, like: + // [type/url] < ... struct contents ... > + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + if tok.value == "[" { + // Looks like an extension or an Any. + // + // TODO: Check whether we need to handle + // namespace rooted names (e.g. ".something.Foo"). + extName, err := p.consumeExtName() + if err != nil { + return err + } + + if s := strings.LastIndex(extName, "/"); s >= 0 { + // If it contains a slash, it's an Any type URL. + messageName := extName[s+1:] + mt := MessageType(messageName) + if mt == nil { + return p.errorf("unrecognized message %q in google.protobuf.Any", messageName) + } + tok = p.next() + if tok.err != nil { + return tok.err + } + // consume an optional colon + if tok.value == ":" { + tok = p.next() + if tok.err != nil { + return tok.err + } + } + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + v := reflect.New(mt.Elem()) + if pe := p.readStruct(v.Elem(), terminator); pe != nil { + return pe + } + b, err := Marshal(v.Interface().(Message)) + if err != nil { + return p.errorf("failed to marshal message of type %q: %v", messageName, err) + } + if fieldSet["type_url"] { + return p.errorf(anyRepeatedlyUnpacked, "type_url") + } + if fieldSet["value"] { + return p.errorf(anyRepeatedlyUnpacked, "value") + } + sv.FieldByName("TypeUrl").SetString(extName) + sv.FieldByName("Value").SetBytes(b) + fieldSet["type_url"] = true + fieldSet["value"] = true + continue + } + + var desc *ExtensionDesc + // This could be faster, but it's functional. + // TODO: Do something smarter than a linear scan. + for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) { + if d.Name == extName { + desc = d + break + } + } + if desc == nil { + return p.errorf("unrecognized extension %q", extName) + } + + props := &Properties{} + props.Parse(desc.Tag) + + typ := reflect.TypeOf(desc.ExtensionType) + if err := p.checkForColon(props, typ); err != nil { + return err + } + + rep := desc.repeated() + + // Read the extension structure, and set it in + // the value we're constructing. + var ext reflect.Value + if !rep { + ext = reflect.New(typ).Elem() + } else { + ext = reflect.New(typ.Elem()).Elem() + } + if err := p.readAny(ext, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } + ep := sv.Addr().Interface().(Message) + if !rep { + SetExtension(ep, desc, ext.Interface()) + } else { + old, err := GetExtension(ep, desc) + var sl reflect.Value + if err == nil { + sl = reflect.ValueOf(old) // existing slice + } else { + sl = reflect.MakeSlice(typ, 0, 1) + } + sl = reflect.Append(sl, ext) + SetExtension(ep, desc, sl.Interface()) + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + continue + } + + // This is a normal, non-extension field. + name := tok.value + var dst reflect.Value + fi, props, ok := structFieldByName(sprops, name) + if ok { + dst = sv.Field(fi) + } else if oop, ok := sprops.OneofTypes[name]; ok { + // It is a oneof. + props = oop.Prop + nv := reflect.New(oop.Type.Elem()) + dst = nv.Elem().Field(0) + field := sv.Field(oop.Field) + if !field.IsNil() { + return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name) + } + field.Set(nv) + } + if !dst.IsValid() { + return p.errorf("unknown field name %q in %v", name, st) + } + + if dst.Kind() == reflect.Map { + // Consume any colon. + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Construct the map if it doesn't already exist. + if dst.IsNil() { + dst.Set(reflect.MakeMap(dst.Type())) + } + key := reflect.New(dst.Type().Key()).Elem() + val := reflect.New(dst.Type().Elem()).Elem() + + // The map entry should be this sequence of tokens: + // < key : KEY value : VALUE > + // However, implementations may omit key or value, and technically + // we should support them in any order. See b/28924776 for a time + // this went wrong. + + tok := p.next() + var terminator string + switch tok.value { + case "<": + terminator = ">" + case "{": + terminator = "}" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + for { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == terminator { + break + } + switch tok.value { + case "key": + if err := p.consumeToken(":"); err != nil { + return err + } + if err := p.readAny(key, props.mkeyprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + case "value": + if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil { + return err + } + if err := p.readAny(val, props.mvalprop); err != nil { + return err + } + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + default: + p.back() + return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) + } + } + + dst.SetMapIndex(key, val) + continue + } + + // Check that it's not already set if it's not a repeated field. + if !props.Repeated && fieldSet[name] { + return p.errorf("non-repeated field %q was repeated", name) + } + + if err := p.checkForColon(props, dst.Type()); err != nil { + return err + } + + // Parse into the field. + fieldSet[name] = true + if err := p.readAny(dst, props); err != nil { + if _, ok := err.(*RequiredNotSetError); !ok { + return err + } + reqFieldErr = err + } + if props.Required { + reqCount-- + } + + if err := p.consumeOptionalSeparator(); err != nil { + return err + } + + } + + if reqCount > 0 { + return p.missingRequiredFieldError(sv) + } + return reqFieldErr +} + +// consumeExtName consumes extension name or expanded Any type URL and the +// following ']'. It returns the name or URL consumed. +func (p *textParser) consumeExtName() (string, error) { + tok := p.next() + if tok.err != nil { + return "", tok.err + } + + // If extension name or type url is quoted, it's a single token. + if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] { + name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0])) + if err != nil { + return "", err + } + return name, p.consumeToken("]") + } + + // Consume everything up to "]" + var parts []string + for tok.value != "]" { + parts = append(parts, tok.value) + tok = p.next() + if tok.err != nil { + return "", p.errorf("unrecognized type_url or extension name: %s", tok.err) + } + } + return strings.Join(parts, ""), nil +} + +// consumeOptionalSeparator consumes an optional semicolon or comma. +// It is used in readStruct to provide backward compatibility. +func (p *textParser) consumeOptionalSeparator() error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value != ";" && tok.value != "," { + p.back() + } + return nil +} + +func (p *textParser) readAny(v reflect.Value, props *Properties) error { + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == "" { + return p.errorf("unexpected EOF") + } + + switch fv := v; fv.Kind() { + case reflect.Slice: + at := v.Type() + if at.Elem().Kind() == reflect.Uint8 { + // Special case for []byte + if tok.value[0] != '"' && tok.value[0] != '\'' { + // Deliberately written out here, as the error after + // this switch statement would write "invalid []byte: ...", + // which is not as user-friendly. + return p.errorf("invalid string: %v", tok.value) + } + bytes := []byte(tok.unquoted) + fv.Set(reflect.ValueOf(bytes)) + return nil + } + // Repeated field. + if tok.value == "[" { + // Repeated field with list notation, like [1,2,3]. + for { + fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) + err := p.readAny(fv.Index(fv.Len()-1), props) + if err != nil { + return err + } + tok := p.next() + if tok.err != nil { + return tok.err + } + if tok.value == "]" { + break + } + if tok.value != "," { + return p.errorf("Expected ']' or ',' found %q", tok.value) + } + } + return nil + } + // One value of the repeated field. + p.back() + fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) + return p.readAny(fv.Index(fv.Len()-1), props) + case reflect.Bool: + // true/1/t/True or false/f/0/False. + switch tok.value { + case "true", "1", "t", "True": + fv.SetBool(true) + return nil + case "false", "0", "f", "False": + fv.SetBool(false) + return nil + } + case reflect.Float32, reflect.Float64: + v := tok.value + // Ignore 'f' for compatibility with output generated by C++, but don't + // remove 'f' when the value is "-inf" or "inf". + if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" { + v = v[:len(v)-1] + } + if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil { + fv.SetFloat(f) + return nil + } + case reflect.Int32: + if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { + fv.SetInt(x) + return nil + } + + if len(props.Enum) == 0 { + break + } + m, ok := enumValueMaps[props.Enum] + if !ok { + break + } + x, ok := m[tok.value] + if !ok { + break + } + fv.SetInt(int64(x)) + return nil + case reflect.Int64: + if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { + fv.SetInt(x) + return nil + } + + case reflect.Ptr: + // A basic field (indirected through pointer), or a repeated message/group + p.back() + fv.Set(reflect.New(fv.Type().Elem())) + return p.readAny(fv.Elem(), props) + case reflect.String: + if tok.value[0] == '"' || tok.value[0] == '\'' { + fv.SetString(tok.unquoted) + return nil + } + case reflect.Struct: + var terminator string + switch tok.value { + case "{": + terminator = "}" + case "<": + terminator = ">" + default: + return p.errorf("expected '{' or '<', found %q", tok.value) + } + // TODO: Handle nested messages which implement encoding.TextUnmarshaler. + return p.readStruct(fv, terminator) + case reflect.Uint32: + if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { + fv.SetUint(uint64(x)) + return nil + } + case reflect.Uint64: + if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { + fv.SetUint(x) + return nil + } + } + return p.errorf("invalid %v: %v", v.Type(), tok.value) +} + +// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb +// before starting to unmarshal, so any existing data in pb is always removed. +// If a required field is not set and no other error occurs, +// UnmarshalText returns *RequiredNotSetError. +func UnmarshalText(s string, pb Message) error { + if um, ok := pb.(encoding.TextUnmarshaler); ok { + err := um.UnmarshalText([]byte(s)) + return err + } + pb.Reset() + v := reflect.ValueOf(pb) + if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil { + return pe + } + return nil +} diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/LICENSE b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/LICENSE new file mode 100644 index 00000000..1b1b1921 --- /dev/null +++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/LICENSE @@ -0,0 +1,31 @@ +Go support for Protocol Buffers - Google's data interchange format + +Copyright 2010 The Go Authors. All rights reserved. +https://github.com/golang/protobuf + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go new file mode 100644 index 00000000..63cf2c80 --- /dev/null +++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go @@ -0,0 +1,2152 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/protobuf/descriptor.proto + +/* +Package descriptor is a generated protocol buffer package. + +It is generated from these files: + google/protobuf/descriptor.proto + +It has these top-level messages: + FileDescriptorSet + FileDescriptorProto + DescriptorProto + FieldDescriptorProto + OneofDescriptorProto + EnumDescriptorProto + EnumValueDescriptorProto + ServiceDescriptorProto + MethodDescriptorProto + FileOptions + MessageOptions + FieldOptions + OneofOptions + EnumOptions + EnumValueOptions + ServiceOptions + MethodOptions + UninterpretedOption + SourceCodeInfo + GeneratedCodeInfo +*/ +package descriptor + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 + +type FieldDescriptorProto_Type int32 + +const ( + // 0 is reserved for errors. + // Order is weird for historical reasons. + FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1 + FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3 + FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4 + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5 + FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6 + FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7 + FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8 + FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9 + // Tag-delimited aggregate. + // Group type is deprecated and not supported in proto3. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. + FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10 + FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11 + // New in version 2. + FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12 + FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13 + FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14 + FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15 + FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16 + FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17 + FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18 +) + +var FieldDescriptorProto_Type_name = map[int32]string{ + 1: "TYPE_DOUBLE", + 2: "TYPE_FLOAT", + 3: "TYPE_INT64", + 4: "TYPE_UINT64", + 5: "TYPE_INT32", + 6: "TYPE_FIXED64", + 7: "TYPE_FIXED32", + 8: "TYPE_BOOL", + 9: "TYPE_STRING", + 10: "TYPE_GROUP", + 11: "TYPE_MESSAGE", + 12: "TYPE_BYTES", + 13: "TYPE_UINT32", + 14: "TYPE_ENUM", + 15: "TYPE_SFIXED32", + 16: "TYPE_SFIXED64", + 17: "TYPE_SINT32", + 18: "TYPE_SINT64", +} +var FieldDescriptorProto_Type_value = map[string]int32{ + "TYPE_DOUBLE": 1, + "TYPE_FLOAT": 2, + "TYPE_INT64": 3, + "TYPE_UINT64": 4, + "TYPE_INT32": 5, + "TYPE_FIXED64": 6, + "TYPE_FIXED32": 7, + "TYPE_BOOL": 8, + "TYPE_STRING": 9, + "TYPE_GROUP": 10, + "TYPE_MESSAGE": 11, + "TYPE_BYTES": 12, + "TYPE_UINT32": 13, + "TYPE_ENUM": 14, + "TYPE_SFIXED32": 15, + "TYPE_SFIXED64": 16, + "TYPE_SINT32": 17, + "TYPE_SINT64": 18, +} + +func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type { + p := new(FieldDescriptorProto_Type) + *p = x + return p +} +func (x FieldDescriptorProto_Type) String() string { + return proto.EnumName(FieldDescriptorProto_Type_name, int32(x)) +} +func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type") + if err != nil { + return err + } + *x = FieldDescriptorProto_Type(value) + return nil +} +func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} } + +type FieldDescriptorProto_Label int32 + +const ( + // 0 is reserved for errors + FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1 + FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2 + FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3 +) + +var FieldDescriptorProto_Label_name = map[int32]string{ + 1: "LABEL_OPTIONAL", + 2: "LABEL_REQUIRED", + 3: "LABEL_REPEATED", +} +var FieldDescriptorProto_Label_value = map[string]int32{ + "LABEL_OPTIONAL": 1, + "LABEL_REQUIRED": 2, + "LABEL_REPEATED": 3, +} + +func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label { + p := new(FieldDescriptorProto_Label) + *p = x + return p +} +func (x FieldDescriptorProto_Label) String() string { + return proto.EnumName(FieldDescriptorProto_Label_name, int32(x)) +} +func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label") + if err != nil { + return err + } + *x = FieldDescriptorProto_Label(value) + return nil +} +func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) { + return fileDescriptor0, []int{3, 1} +} + +// Generated classes can be optimized for speed or code size. +type FileOptions_OptimizeMode int32 + +const ( + FileOptions_SPEED FileOptions_OptimizeMode = 1 + // etc. + FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 + FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 +) + +var FileOptions_OptimizeMode_name = map[int32]string{ + 1: "SPEED", + 2: "CODE_SIZE", + 3: "LITE_RUNTIME", +} +var FileOptions_OptimizeMode_value = map[string]int32{ + "SPEED": 1, + "CODE_SIZE": 2, + "LITE_RUNTIME": 3, +} + +func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode { + p := new(FileOptions_OptimizeMode) + *p = x + return p +} +func (x FileOptions_OptimizeMode) String() string { + return proto.EnumName(FileOptions_OptimizeMode_name, int32(x)) +} +func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode") + if err != nil { + return err + } + *x = FileOptions_OptimizeMode(value) + return nil +} +func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9, 0} } + +type FieldOptions_CType int32 + +const ( + // Default mode. + FieldOptions_STRING FieldOptions_CType = 0 + FieldOptions_CORD FieldOptions_CType = 1 + FieldOptions_STRING_PIECE FieldOptions_CType = 2 +) + +var FieldOptions_CType_name = map[int32]string{ + 0: "STRING", + 1: "CORD", + 2: "STRING_PIECE", +} +var FieldOptions_CType_value = map[string]int32{ + "STRING": 0, + "CORD": 1, + "STRING_PIECE": 2, +} + +func (x FieldOptions_CType) Enum() *FieldOptions_CType { + p := new(FieldOptions_CType) + *p = x + return p +} +func (x FieldOptions_CType) String() string { + return proto.EnumName(FieldOptions_CType_name, int32(x)) +} +func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType") + if err != nil { + return err + } + *x = FieldOptions_CType(value) + return nil +} +func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11, 0} } + +type FieldOptions_JSType int32 + +const ( + // Use the default type. + FieldOptions_JS_NORMAL FieldOptions_JSType = 0 + // Use JavaScript strings. + FieldOptions_JS_STRING FieldOptions_JSType = 1 + // Use JavaScript numbers. + FieldOptions_JS_NUMBER FieldOptions_JSType = 2 +) + +var FieldOptions_JSType_name = map[int32]string{ + 0: "JS_NORMAL", + 1: "JS_STRING", + 2: "JS_NUMBER", +} +var FieldOptions_JSType_value = map[string]int32{ + "JS_NORMAL": 0, + "JS_STRING": 1, + "JS_NUMBER": 2, +} + +func (x FieldOptions_JSType) Enum() *FieldOptions_JSType { + p := new(FieldOptions_JSType) + *p = x + return p +} +func (x FieldOptions_JSType) String() string { + return proto.EnumName(FieldOptions_JSType_name, int32(x)) +} +func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType") + if err != nil { + return err + } + *x = FieldOptions_JSType(value) + return nil +} +func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11, 1} } + +// Is this method side-effect-free (or safe in HTTP parlance), or idempotent, +// or neither? HTTP based RPC implementation may choose GET verb for safe +// methods, and PUT verb for idempotent methods instead of the default POST. +type MethodOptions_IdempotencyLevel int32 + +const ( + MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0 + MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1 + MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2 +) + +var MethodOptions_IdempotencyLevel_name = map[int32]string{ + 0: "IDEMPOTENCY_UNKNOWN", + 1: "NO_SIDE_EFFECTS", + 2: "IDEMPOTENT", +} +var MethodOptions_IdempotencyLevel_value = map[string]int32{ + "IDEMPOTENCY_UNKNOWN": 0, + "NO_SIDE_EFFECTS": 1, + "IDEMPOTENT": 2, +} + +func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel { + p := new(MethodOptions_IdempotencyLevel) + *p = x + return p +} +func (x MethodOptions_IdempotencyLevel) String() string { + return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x)) +} +func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel") + if err != nil { + return err + } + *x = MethodOptions_IdempotencyLevel(value) + return nil +} +func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) { + return fileDescriptor0, []int{16, 0} +} + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +type FileDescriptorSet struct { + File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} } +func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorSet) ProtoMessage() {} +func (*FileDescriptorSet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto { + if m != nil { + return m.File + } + return nil +} + +// Describes a complete .proto file. +type FileDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"` + // Names of files imported by this file. + Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"` + // Indexes of the public imported files in the dependency list above. + PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"` + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"` + // All top-level definitions in this file. + MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"` + Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"` + // The syntax of the proto file. + // The supported values are "proto2" and "proto3". + Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} } +func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FileDescriptorProto) ProtoMessage() {} +func (*FileDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +func (m *FileDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FileDescriptorProto) GetPackage() string { + if m != nil && m.Package != nil { + return *m.Package + } + return "" +} + +func (m *FileDescriptorProto) GetDependency() []string { + if m != nil { + return m.Dependency + } + return nil +} + +func (m *FileDescriptorProto) GetPublicDependency() []int32 { + if m != nil { + return m.PublicDependency + } + return nil +} + +func (m *FileDescriptorProto) GetWeakDependency() []int32 { + if m != nil { + return m.WeakDependency + } + return nil +} + +func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto { + if m != nil { + return m.MessageType + } + return nil +} + +func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto { + if m != nil { + return m.Service + } + return nil +} + +func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *FileDescriptorProto) GetOptions() *FileOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo { + if m != nil { + return m.SourceCodeInfo + } + return nil +} + +func (m *FileDescriptorProto) GetSyntax() string { + if m != nil && m.Syntax != nil { + return *m.Syntax + } + return "" +} + +// Describes a message type. +type DescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"` + Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"` + NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"` + EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"` + ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"` + OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"` + Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"` + ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"` + // Reserved field names, which may not be used by fields in the same message. + // A given name may only be reserved once. + ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto) Reset() { *m = DescriptorProto{} } +func (m *DescriptorProto) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto) ProtoMessage() {} +func (*DescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +func (m *DescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *DescriptorProto) GetField() []*FieldDescriptorProto { + if m != nil { + return m.Field + } + return nil +} + +func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto { + if m != nil { + return m.Extension + } + return nil +} + +func (m *DescriptorProto) GetNestedType() []*DescriptorProto { + if m != nil { + return m.NestedType + } + return nil +} + +func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto { + if m != nil { + return m.EnumType + } + return nil +} + +func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange { + if m != nil { + return m.ExtensionRange + } + return nil +} + +func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto { + if m != nil { + return m.OneofDecl + } + return nil +} + +func (m *DescriptorProto) GetOptions() *MessageOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange { + if m != nil { + return m.ReservedRange + } + return nil +} + +func (m *DescriptorProto) GetReservedName() []string { + if m != nil { + return m.ReservedName + } + return nil +} + +type DescriptorProto_ExtensionRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} } +func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto_ExtensionRange) ProtoMessage() {} +func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{2, 0} +} + +func (m *DescriptorProto_ExtensionRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *DescriptorProto_ExtensionRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +// Range of reserved tag numbers. Reserved tag numbers may not be used by +// fields or extension ranges in the same message. Reserved ranges may +// not overlap. +type DescriptorProto_ReservedRange struct { + Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} } +func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) } +func (*DescriptorProto_ReservedRange) ProtoMessage() {} +func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{2, 1} +} + +func (m *DescriptorProto_ReservedRange) GetStart() int32 { + if m != nil && m.Start != nil { + return *m.Start + } + return 0 +} + +func (m *DescriptorProto_ReservedRange) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +// Describes a field within a message. +type FieldDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"` + Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"` + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"` + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"` + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"` + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + // TODO(kenton): Base-64 encode? + DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"` + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. + OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"` + // JSON name of this field. The value is set by protocol compiler. If the + // user has set a "json_name" option on this field, that option's value + // will be used. Otherwise, it's deduced from the field's name by converting + // it to camelCase. + JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"` + Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} } +func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*FieldDescriptorProto) ProtoMessage() {} +func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *FieldDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *FieldDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label { + if m != nil && m.Label != nil { + return *m.Label + } + return FieldDescriptorProto_LABEL_OPTIONAL +} + +func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type { + if m != nil && m.Type != nil { + return *m.Type + } + return FieldDescriptorProto_TYPE_DOUBLE +} + +func (m *FieldDescriptorProto) GetTypeName() string { + if m != nil && m.TypeName != nil { + return *m.TypeName + } + return "" +} + +func (m *FieldDescriptorProto) GetExtendee() string { + if m != nil && m.Extendee != nil { + return *m.Extendee + } + return "" +} + +func (m *FieldDescriptorProto) GetDefaultValue() string { + if m != nil && m.DefaultValue != nil { + return *m.DefaultValue + } + return "" +} + +func (m *FieldDescriptorProto) GetOneofIndex() int32 { + if m != nil && m.OneofIndex != nil { + return *m.OneofIndex + } + return 0 +} + +func (m *FieldDescriptorProto) GetJsonName() string { + if m != nil && m.JsonName != nil { + return *m.JsonName + } + return "" +} + +func (m *FieldDescriptorProto) GetOptions() *FieldOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a oneof. +type OneofDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} } +func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*OneofDescriptorProto) ProtoMessage() {} +func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + +func (m *OneofDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *OneofDescriptorProto) GetOptions() *OneofOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes an enum type. +type EnumDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` + Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} } +func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumDescriptorProto) ProtoMessage() {} +func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + +func (m *EnumDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto { + if m != nil { + return m.Value + } + return nil +} + +func (m *EnumDescriptorProto) GetOptions() *EnumOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a value within an enum. +type EnumValueDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"` + Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} } +func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*EnumValueDescriptorProto) ProtoMessage() {} +func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + +func (m *EnumValueDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *EnumValueDescriptorProto) GetNumber() int32 { + if m != nil && m.Number != nil { + return *m.Number + } + return 0 +} + +func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a service. +type ServiceDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"` + Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} } +func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*ServiceDescriptorProto) ProtoMessage() {} +func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +func (m *ServiceDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto { + if m != nil { + return m.Method + } + return nil +} + +func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions { + if m != nil { + return m.Options + } + return nil +} + +// Describes a method of a service. +type MethodDescriptorProto struct { + Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"` + OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"` + Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"` + // Identifies if client streams multiple client messages + ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"` + // Identifies if server streams multiple server messages + ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} } +func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) } +func (*MethodDescriptorProto) ProtoMessage() {} +func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } + +const Default_MethodDescriptorProto_ClientStreaming bool = false +const Default_MethodDescriptorProto_ServerStreaming bool = false + +func (m *MethodDescriptorProto) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *MethodDescriptorProto) GetInputType() string { + if m != nil && m.InputType != nil { + return *m.InputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOutputType() string { + if m != nil && m.OutputType != nil { + return *m.OutputType + } + return "" +} + +func (m *MethodDescriptorProto) GetOptions() *MethodOptions { + if m != nil { + return m.Options + } + return nil +} + +func (m *MethodDescriptorProto) GetClientStreaming() bool { + if m != nil && m.ClientStreaming != nil { + return *m.ClientStreaming + } + return Default_MethodDescriptorProto_ClientStreaming +} + +func (m *MethodDescriptorProto) GetServerStreaming() bool { + if m != nil && m.ServerStreaming != nil { + return *m.ServerStreaming + } + return Default_MethodDescriptorProto_ServerStreaming +} + +type FileOptions struct { + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"` + // If set, all the classes from the .proto file are wrapped in a single + // outer class with the given name. This applies to both Proto1 + // (equivalent to the old "--one_java_file" option) and Proto2 (where + // a .proto always translates to a single class, but you may want to + // explicitly choose the class name). + JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"` + // If set true, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the outer class + // named by java_outer_classname. However, the outer class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"` + // This option does nothing. + JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` + // If set true, then the Java2 code generator will generate code that + // throws an exception whenever an attempt is made to assign a non-UTF-8 + // byte sequence to a string field. + // Message reflection will do the same. + // However, an extension field still accepts non-UTF-8 byte sequences. + // This option has no effect on when used with the lite runtime. + JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"` + OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"` + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"` + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"` + JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"` + PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"` + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"` + // Sets the objective c class prefix which is prepended to all objective c + // generated classes from this .proto. There is no default. + ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"` + // Namespace for generated classes; defaults to the package. + CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"` + // By default Swift generators will take the proto package and CamelCase it + // replacing '.' with underscore and use that to prefix the types/symbols + // defined. When this options is provided, they will use this value instead + // to prefix the types/symbols defined. + SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"` + // Sets the php class prefix which is prepended to all php generated classes + // from this .proto. Default is empty. + PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FileOptions) Reset() { *m = FileOptions{} } +func (m *FileOptions) String() string { return proto.CompactTextString(m) } +func (*FileOptions) ProtoMessage() {} +func (*FileOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + +var extRange_FileOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FileOptions +} + +const Default_FileOptions_JavaMultipleFiles bool = false +const Default_FileOptions_JavaStringCheckUtf8 bool = false +const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED +const Default_FileOptions_CcGenericServices bool = false +const Default_FileOptions_JavaGenericServices bool = false +const Default_FileOptions_PyGenericServices bool = false +const Default_FileOptions_Deprecated bool = false +const Default_FileOptions_CcEnableArenas bool = false + +func (m *FileOptions) GetJavaPackage() string { + if m != nil && m.JavaPackage != nil { + return *m.JavaPackage + } + return "" +} + +func (m *FileOptions) GetJavaOuterClassname() string { + if m != nil && m.JavaOuterClassname != nil { + return *m.JavaOuterClassname + } + return "" +} + +func (m *FileOptions) GetJavaMultipleFiles() bool { + if m != nil && m.JavaMultipleFiles != nil { + return *m.JavaMultipleFiles + } + return Default_FileOptions_JavaMultipleFiles +} + +func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool { + if m != nil && m.JavaGenerateEqualsAndHash != nil { + return *m.JavaGenerateEqualsAndHash + } + return false +} + +func (m *FileOptions) GetJavaStringCheckUtf8() bool { + if m != nil && m.JavaStringCheckUtf8 != nil { + return *m.JavaStringCheckUtf8 + } + return Default_FileOptions_JavaStringCheckUtf8 +} + +func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode { + if m != nil && m.OptimizeFor != nil { + return *m.OptimizeFor + } + return Default_FileOptions_OptimizeFor +} + +func (m *FileOptions) GetGoPackage() string { + if m != nil && m.GoPackage != nil { + return *m.GoPackage + } + return "" +} + +func (m *FileOptions) GetCcGenericServices() bool { + if m != nil && m.CcGenericServices != nil { + return *m.CcGenericServices + } + return Default_FileOptions_CcGenericServices +} + +func (m *FileOptions) GetJavaGenericServices() bool { + if m != nil && m.JavaGenericServices != nil { + return *m.JavaGenericServices + } + return Default_FileOptions_JavaGenericServices +} + +func (m *FileOptions) GetPyGenericServices() bool { + if m != nil && m.PyGenericServices != nil { + return *m.PyGenericServices + } + return Default_FileOptions_PyGenericServices +} + +func (m *FileOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FileOptions_Deprecated +} + +func (m *FileOptions) GetCcEnableArenas() bool { + if m != nil && m.CcEnableArenas != nil { + return *m.CcEnableArenas + } + return Default_FileOptions_CcEnableArenas +} + +func (m *FileOptions) GetObjcClassPrefix() string { + if m != nil && m.ObjcClassPrefix != nil { + return *m.ObjcClassPrefix + } + return "" +} + +func (m *FileOptions) GetCsharpNamespace() string { + if m != nil && m.CsharpNamespace != nil { + return *m.CsharpNamespace + } + return "" +} + +func (m *FileOptions) GetSwiftPrefix() string { + if m != nil && m.SwiftPrefix != nil { + return *m.SwiftPrefix + } + return "" +} + +func (m *FileOptions) GetPhpClassPrefix() string { + if m != nil && m.PhpClassPrefix != nil { + return *m.PhpClassPrefix + } + return "" +} + +func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MessageOptions struct { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"` + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"` + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementions still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MessageOptions) Reset() { *m = MessageOptions{} } +func (m *MessageOptions) String() string { return proto.CompactTextString(m) } +func (*MessageOptions) ProtoMessage() {} +func (*MessageOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } + +var extRange_MessageOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MessageOptions +} + +const Default_MessageOptions_MessageSetWireFormat bool = false +const Default_MessageOptions_NoStandardDescriptorAccessor bool = false +const Default_MessageOptions_Deprecated bool = false + +func (m *MessageOptions) GetMessageSetWireFormat() bool { + if m != nil && m.MessageSetWireFormat != nil { + return *m.MessageSetWireFormat + } + return Default_MessageOptions_MessageSetWireFormat +} + +func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool { + if m != nil && m.NoStandardDescriptorAccessor != nil { + return *m.NoStandardDescriptorAccessor + } + return Default_MessageOptions_NoStandardDescriptorAccessor +} + +func (m *MessageOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MessageOptions_Deprecated +} + +func (m *MessageOptions) GetMapEntry() bool { + if m != nil && m.MapEntry != nil { + return *m.MapEntry + } + return false +} + +func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type FieldOptions struct { + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is not yet implemented in the open source + // release -- sorry, we'll try to include it in a future version! + Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"` + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. In proto3, only explicit setting it to + // false will avoid using packed encoding. + Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"` + // The jstype option determines the JavaScript type used for values of the + // field. The option is permitted only for 64 bit integral and fixed types + // (int64, uint64, sint64, fixed64, sfixed64). By default these types are + // represented as JavaScript strings. This avoids loss of precision that can + // happen when a large value is converted to a floating point JavaScript + // numbers. Specifying JS_NUMBER for the jstype causes the generated + // JavaScript code to use the JavaScript "number" type instead of strings. + // This option is an enum to permit additional types to be added, + // e.g. goog.math.Integer. + Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"` + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // + // Note that implementations may choose not to check required fields within + // a lazy sub-message. That is, calling IsInitialized() on the outer message + // may return true even if the inner message has missing required fields. + // This is necessary because otherwise the inner message would have to be + // parsed in order to perform the check, defeating the purpose of lazy + // parsing. An implementation which chooses not to check required fields + // must be consistent about it. That is, for any particular sub-message, the + // implementation must either *always* check its required fields, or *never* + // check its required fields, regardless of whether or not the message has + // been parsed. + Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"` + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // For Google-internal migration only. Do not use. + Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldOptions) Reset() { *m = FieldOptions{} } +func (m *FieldOptions) String() string { return proto.CompactTextString(m) } +func (*FieldOptions) ProtoMessage() {} +func (*FieldOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } + +var extRange_FieldOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_FieldOptions +} + +const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING +const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL +const Default_FieldOptions_Lazy bool = false +const Default_FieldOptions_Deprecated bool = false +const Default_FieldOptions_Weak bool = false + +func (m *FieldOptions) GetCtype() FieldOptions_CType { + if m != nil && m.Ctype != nil { + return *m.Ctype + } + return Default_FieldOptions_Ctype +} + +func (m *FieldOptions) GetPacked() bool { + if m != nil && m.Packed != nil { + return *m.Packed + } + return false +} + +func (m *FieldOptions) GetJstype() FieldOptions_JSType { + if m != nil && m.Jstype != nil { + return *m.Jstype + } + return Default_FieldOptions_Jstype +} + +func (m *FieldOptions) GetLazy() bool { + if m != nil && m.Lazy != nil { + return *m.Lazy + } + return Default_FieldOptions_Lazy +} + +func (m *FieldOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_FieldOptions_Deprecated +} + +func (m *FieldOptions) GetWeak() bool { + if m != nil && m.Weak != nil { + return *m.Weak + } + return Default_FieldOptions_Weak +} + +func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type OneofOptions struct { + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *OneofOptions) Reset() { *m = OneofOptions{} } +func (m *OneofOptions) String() string { return proto.CompactTextString(m) } +func (*OneofOptions) ProtoMessage() {} +func (*OneofOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } + +var extRange_OneofOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_OneofOptions +} + +func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumOptions struct { + // Set this option to true to allow mapping different tag names to the same + // value. + AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"` + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumOptions) Reset() { *m = EnumOptions{} } +func (m *EnumOptions) String() string { return proto.CompactTextString(m) } +func (*EnumOptions) ProtoMessage() {} +func (*EnumOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } + +var extRange_EnumOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumOptions +} + +const Default_EnumOptions_Deprecated bool = false + +func (m *EnumOptions) GetAllowAlias() bool { + if m != nil && m.AllowAlias != nil { + return *m.AllowAlias + } + return false +} + +func (m *EnumOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumOptions_Deprecated +} + +func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type EnumValueOptions struct { + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} } +func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) } +func (*EnumValueOptions) ProtoMessage() {} +func (*EnumValueOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } + +var extRange_EnumValueOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_EnumValueOptions +} + +const Default_EnumValueOptions_Deprecated bool = false + +func (m *EnumValueOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_EnumValueOptions_Deprecated +} + +func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type ServiceOptions struct { + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ServiceOptions) Reset() { *m = ServiceOptions{} } +func (m *ServiceOptions) String() string { return proto.CompactTextString(m) } +func (*ServiceOptions) ProtoMessage() {} +func (*ServiceOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } + +var extRange_ServiceOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_ServiceOptions +} + +const Default_ServiceOptions_Deprecated bool = false + +func (m *ServiceOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_ServiceOptions_Deprecated +} + +func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +type MethodOptions struct { + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"` + IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"` + // The parser stores options it doesn't recognize here. See above. + UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MethodOptions) Reset() { *m = MethodOptions{} } +func (m *MethodOptions) String() string { return proto.CompactTextString(m) } +func (*MethodOptions) ProtoMessage() {} +func (*MethodOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } + +var extRange_MethodOptions = []proto.ExtensionRange{ + {1000, 536870911}, +} + +func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_MethodOptions +} + +const Default_MethodOptions_Deprecated bool = false +const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN + +func (m *MethodOptions) GetDeprecated() bool { + if m != nil && m.Deprecated != nil { + return *m.Deprecated + } + return Default_MethodOptions_Deprecated +} + +func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel { + if m != nil && m.IdempotencyLevel != nil { + return *m.IdempotencyLevel + } + return Default_MethodOptions_IdempotencyLevel +} + +func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption { + if m != nil { + return m.UninterpretedOption + } + return nil +} + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +type UninterpretedOption struct { + Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"` + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"` + PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"` + NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"` + DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"` + StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"` + AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} } +func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption) ProtoMessage() {} +func (*UninterpretedOption) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } + +func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart { + if m != nil { + return m.Name + } + return nil +} + +func (m *UninterpretedOption) GetIdentifierValue() string { + if m != nil && m.IdentifierValue != nil { + return *m.IdentifierValue + } + return "" +} + +func (m *UninterpretedOption) GetPositiveIntValue() uint64 { + if m != nil && m.PositiveIntValue != nil { + return *m.PositiveIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetNegativeIntValue() int64 { + if m != nil && m.NegativeIntValue != nil { + return *m.NegativeIntValue + } + return 0 +} + +func (m *UninterpretedOption) GetDoubleValue() float64 { + if m != nil && m.DoubleValue != nil { + return *m.DoubleValue + } + return 0 +} + +func (m *UninterpretedOption) GetStringValue() []byte { + if m != nil { + return m.StringValue + } + return nil +} + +func (m *UninterpretedOption) GetAggregateValue() string { + if m != nil && m.AggregateValue != nil { + return *m.AggregateValue + } + return "" +} + +// The name of the uninterpreted option. Each string represents a segment in +// a dot-separated name. is_extension is true iff a segment represents an +// extension (denoted with parentheses in options specs in .proto files). +// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents +// "foo.(bar.baz).qux". +type UninterpretedOption_NamePart struct { + NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"` + IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} } +func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) } +func (*UninterpretedOption_NamePart) ProtoMessage() {} +func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{17, 0} +} + +func (m *UninterpretedOption_NamePart) GetNamePart() string { + if m != nil && m.NamePart != nil { + return *m.NamePart + } + return "" +} + +func (m *UninterpretedOption_NamePart) GetIsExtension() bool { + if m != nil && m.IsExtension != nil { + return *m.IsExtension + } + return false +} + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +type SourceCodeInfo struct { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendent. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} } +func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo) ProtoMessage() {} +func (*SourceCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } + +func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location { + if m != nil { + return m.Location + } + return nil +} + +type SourceCodeInfo_Location struct { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition. For + // example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"` + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // leading_detached_comments will keep paragraphs of comments that appear + // before (but not connected to) the current element. Each paragraph, + // separated by empty lines, will be one comment element in the repeated + // field. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to qux. + // // + // // Another line attached to qux. + // optional double qux = 4; + // + // // Detached comment for corge. This is not leading or trailing comments + // // to qux or corge because there are blank lines separating it from + // // both. + // + // // Detached comment for corge paragraph 2. + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + // + // // ignored detached comments. + LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"` + TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"` + LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} } +func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) } +func (*SourceCodeInfo_Location) ProtoMessage() {} +func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18, 0} } + +func (m *SourceCodeInfo_Location) GetPath() []int32 { + if m != nil { + return m.Path + } + return nil +} + +func (m *SourceCodeInfo_Location) GetSpan() []int32 { + if m != nil { + return m.Span + } + return nil +} + +func (m *SourceCodeInfo_Location) GetLeadingComments() string { + if m != nil && m.LeadingComments != nil { + return *m.LeadingComments + } + return "" +} + +func (m *SourceCodeInfo_Location) GetTrailingComments() string { + if m != nil && m.TrailingComments != nil { + return *m.TrailingComments + } + return "" +} + +func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string { + if m != nil { + return m.LeadingDetachedComments + } + return nil +} + +// Describes the relationship between generated code and its original source +// file. A GeneratedCodeInfo message is associated with only one generated +// source file, but may contain references to different source .proto files. +type GeneratedCodeInfo struct { + // An Annotation connects some span of text in generated code to an element + // of its generating .proto file. + Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GeneratedCodeInfo) Reset() { *m = GeneratedCodeInfo{} } +func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) } +func (*GeneratedCodeInfo) ProtoMessage() {} +func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } + +func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation { + if m != nil { + return m.Annotation + } + return nil +} + +type GeneratedCodeInfo_Annotation struct { + // Identifies the element in the original source .proto file. This field + // is formatted the same as SourceCodeInfo.Location.path. + Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"` + // Identifies the filesystem path to the original source .proto. + SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"` + // Identifies the starting offset in bytes in the generated code + // that relates to the identified object. + Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"` + // Identifies the ending offset in bytes in the generated code that + // relates to the identified offset. The end offset should be one past + // the last relevant byte (so the length of the text = end - begin). + End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GeneratedCodeInfo_Annotation) Reset() { *m = GeneratedCodeInfo_Annotation{} } +func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) } +func (*GeneratedCodeInfo_Annotation) ProtoMessage() {} +func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{19, 0} +} + +func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 { + if m != nil { + return m.Path + } + return nil +} + +func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string { + if m != nil && m.SourceFile != nil { + return *m.SourceFile + } + return "" +} + +func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 { + if m != nil && m.Begin != nil { + return *m.Begin + } + return 0 +} + +func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 { + if m != nil && m.End != nil { + return *m.End + } + return 0 +} + +func init() { + proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet") + proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto") + proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto") + proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange") + proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange") + proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto") + proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto") + proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto") + proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto") + proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto") + proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto") + proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions") + proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions") + proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions") + proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions") + proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions") + proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions") + proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions") + proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions") + proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption") + proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart") + proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo") + proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location") + proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo") + proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation") + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value) + proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value) + proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value) + proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value) + proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value) + proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value) +} + +func init() { proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 2460 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0x5b, 0x6f, 0xdb, 0xc8, + 0x15, 0x5e, 0x5d, 0x2d, 0x1d, 0xc9, 0xf2, 0x78, 0xec, 0x4d, 0x18, 0xef, 0x25, 0x8e, 0xf6, 0x12, + 0x6f, 0xd2, 0xc8, 0x0b, 0xe7, 0xb2, 0x59, 0xa7, 0x48, 0x21, 0x4b, 0x8c, 0x57, 0xa9, 0x2c, 0xa9, + 0x94, 0xdc, 0x4d, 0xf6, 0x85, 0x18, 0x93, 0x23, 0x99, 0x09, 0x45, 0x72, 0x49, 0x2a, 0x89, 0xf7, + 0x29, 0x40, 0x9f, 0x0a, 0xf4, 0x07, 0x14, 0x45, 0xd1, 0x87, 0x7d, 0x59, 0xa0, 0x3f, 0xa0, 0xcf, + 0xfd, 0x05, 0x05, 0xf6, 0xb9, 0x2f, 0x45, 0x51, 0xa0, 0xfd, 0x07, 0x7d, 0x2d, 0x66, 0x86, 0xa4, + 0x48, 0x5d, 0x12, 0x77, 0x81, 0xec, 0x3e, 0xd9, 0x73, 0xce, 0x77, 0x0e, 0xcf, 0x9c, 0xf9, 0x66, + 0xce, 0x99, 0x11, 0x6c, 0x8f, 0x6c, 0x7b, 0x64, 0xd2, 0x5d, 0xc7, 0xb5, 0x7d, 0xfb, 0x64, 0x32, + 0xdc, 0xd5, 0xa9, 0xa7, 0xb9, 0x86, 0xe3, 0xdb, 0x6e, 0x8d, 0xcb, 0xf0, 0x9a, 0x40, 0xd4, 0x42, + 0x44, 0xf5, 0x08, 0xd6, 0x1f, 0x18, 0x26, 0x6d, 0x46, 0xc0, 0x3e, 0xf5, 0xf1, 0x5d, 0xc8, 0x0e, + 0x0d, 0x93, 0x4a, 0xa9, 0xed, 0xcc, 0x4e, 0x69, 0xef, 0xc3, 0xda, 0x8c, 0x51, 0x2d, 0x69, 0xd1, + 0x63, 0x62, 0x85, 0x5b, 0x54, 0xff, 0x95, 0x85, 0x8d, 0x05, 0x5a, 0x8c, 0x21, 0x6b, 0x91, 0x31, + 0xf3, 0x98, 0xda, 0x29, 0x2a, 0xfc, 0x7f, 0x2c, 0xc1, 0x8a, 0x43, 0xb4, 0xa7, 0x64, 0x44, 0xa5, + 0x34, 0x17, 0x87, 0x43, 0xfc, 0x3e, 0x80, 0x4e, 0x1d, 0x6a, 0xe9, 0xd4, 0xd2, 0xce, 0xa4, 0xcc, + 0x76, 0x66, 0xa7, 0xa8, 0xc4, 0x24, 0xf8, 0x3a, 0xac, 0x3b, 0x93, 0x13, 0xd3, 0xd0, 0xd4, 0x18, + 0x0c, 0xb6, 0x33, 0x3b, 0x39, 0x05, 0x09, 0x45, 0x73, 0x0a, 0xbe, 0x0a, 0x6b, 0xcf, 0x29, 0x79, + 0x1a, 0x87, 0x96, 0x38, 0xb4, 0xc2, 0xc4, 0x31, 0x60, 0x03, 0xca, 0x63, 0xea, 0x79, 0x64, 0x44, + 0x55, 0xff, 0xcc, 0xa1, 0x52, 0x96, 0xcf, 0x7e, 0x7b, 0x6e, 0xf6, 0xb3, 0x33, 0x2f, 0x05, 0x56, + 0x83, 0x33, 0x87, 0xe2, 0x3a, 0x14, 0xa9, 0x35, 0x19, 0x0b, 0x0f, 0xb9, 0x25, 0xf9, 0x93, 0xad, + 0xc9, 0x78, 0xd6, 0x4b, 0x81, 0x99, 0x05, 0x2e, 0x56, 0x3c, 0xea, 0x3e, 0x33, 0x34, 0x2a, 0xe5, + 0xb9, 0x83, 0xab, 0x73, 0x0e, 0xfa, 0x42, 0x3f, 0xeb, 0x23, 0xb4, 0xc3, 0x0d, 0x28, 0xd2, 0x17, + 0x3e, 0xb5, 0x3c, 0xc3, 0xb6, 0xa4, 0x15, 0xee, 0xe4, 0xa3, 0x05, 0xab, 0x48, 0x4d, 0x7d, 0xd6, + 0xc5, 0xd4, 0x0e, 0xdf, 0x81, 0x15, 0xdb, 0xf1, 0x0d, 0xdb, 0xf2, 0xa4, 0xc2, 0x76, 0x6a, 0xa7, + 0xb4, 0xf7, 0xee, 0x42, 0x22, 0x74, 0x05, 0x46, 0x09, 0xc1, 0xb8, 0x05, 0xc8, 0xb3, 0x27, 0xae, + 0x46, 0x55, 0xcd, 0xd6, 0xa9, 0x6a, 0x58, 0x43, 0x5b, 0x2a, 0x72, 0x07, 0x97, 0xe7, 0x27, 0xc2, + 0x81, 0x0d, 0x5b, 0xa7, 0x2d, 0x6b, 0x68, 0x2b, 0x15, 0x2f, 0x31, 0xc6, 0x17, 0x20, 0xef, 0x9d, + 0x59, 0x3e, 0x79, 0x21, 0x95, 0x39, 0x43, 0x82, 0x51, 0xf5, 0xbf, 0x39, 0x58, 0x3b, 0x0f, 0xc5, + 0xee, 0x41, 0x6e, 0xc8, 0x66, 0x29, 0xa5, 0xff, 0x9f, 0x1c, 0x08, 0x9b, 0x64, 0x12, 0xf3, 0x3f, + 0x30, 0x89, 0x75, 0x28, 0x59, 0xd4, 0xf3, 0xa9, 0x2e, 0x18, 0x91, 0x39, 0x27, 0xa7, 0x40, 0x18, + 0xcd, 0x53, 0x2a, 0xfb, 0x83, 0x28, 0xf5, 0x08, 0xd6, 0xa2, 0x90, 0x54, 0x97, 0x58, 0xa3, 0x90, + 0x9b, 0xbb, 0xaf, 0x8b, 0xa4, 0x26, 0x87, 0x76, 0x0a, 0x33, 0x53, 0x2a, 0x34, 0x31, 0xc6, 0x4d, + 0x00, 0xdb, 0xa2, 0xf6, 0x50, 0xd5, 0xa9, 0x66, 0x4a, 0x85, 0x25, 0x59, 0xea, 0x32, 0xc8, 0x5c, + 0x96, 0x6c, 0x21, 0xd5, 0x4c, 0xfc, 0xf9, 0x94, 0x6a, 0x2b, 0x4b, 0x98, 0x72, 0x24, 0x36, 0xd9, + 0x1c, 0xdb, 0x8e, 0xa1, 0xe2, 0x52, 0xc6, 0x7b, 0xaa, 0x07, 0x33, 0x2b, 0xf2, 0x20, 0x6a, 0xaf, + 0x9d, 0x99, 0x12, 0x98, 0x89, 0x89, 0xad, 0xba, 0xf1, 0x21, 0xfe, 0x00, 0x22, 0x81, 0xca, 0x69, + 0x05, 0xfc, 0x14, 0x2a, 0x87, 0xc2, 0x0e, 0x19, 0xd3, 0xad, 0xbb, 0x50, 0x49, 0xa6, 0x07, 0x6f, + 0x42, 0xce, 0xf3, 0x89, 0xeb, 0x73, 0x16, 0xe6, 0x14, 0x31, 0xc0, 0x08, 0x32, 0xd4, 0xd2, 0xf9, + 0x29, 0x97, 0x53, 0xd8, 0xbf, 0x5b, 0x9f, 0xc1, 0x6a, 0xe2, 0xf3, 0xe7, 0x35, 0xac, 0xfe, 0x3e, + 0x0f, 0x9b, 0x8b, 0x38, 0xb7, 0x90, 0xfe, 0x17, 0x20, 0x6f, 0x4d, 0xc6, 0x27, 0xd4, 0x95, 0x32, + 0xdc, 0x43, 0x30, 0xc2, 0x75, 0xc8, 0x99, 0xe4, 0x84, 0x9a, 0x52, 0x76, 0x3b, 0xb5, 0x53, 0xd9, + 0xbb, 0x7e, 0x2e, 0x56, 0xd7, 0xda, 0xcc, 0x44, 0x11, 0x96, 0xf8, 0x3e, 0x64, 0x83, 0x23, 0x8e, + 0x79, 0xb8, 0x76, 0x3e, 0x0f, 0x8c, 0x8b, 0x0a, 0xb7, 0xc3, 0xef, 0x40, 0x91, 0xfd, 0x15, 0xb9, + 0xcd, 0xf3, 0x98, 0x0b, 0x4c, 0xc0, 0xf2, 0x8a, 0xb7, 0xa0, 0xc0, 0x69, 0xa6, 0xd3, 0xb0, 0x34, + 0x44, 0x63, 0xb6, 0x30, 0x3a, 0x1d, 0x92, 0x89, 0xe9, 0xab, 0xcf, 0x88, 0x39, 0xa1, 0x9c, 0x30, + 0x45, 0xa5, 0x1c, 0x08, 0x7f, 0xcd, 0x64, 0xf8, 0x32, 0x94, 0x04, 0x2b, 0x0d, 0x4b, 0xa7, 0x2f, + 0xf8, 0xe9, 0x93, 0x53, 0x04, 0x51, 0x5b, 0x4c, 0xc2, 0x3e, 0xff, 0xc4, 0xb3, 0xad, 0x70, 0x69, + 0xf9, 0x27, 0x98, 0x80, 0x7f, 0xfe, 0xb3, 0xd9, 0x83, 0xef, 0xbd, 0xc5, 0xd3, 0x9b, 0xe5, 0x62, + 0xf5, 0x2f, 0x69, 0xc8, 0xf2, 0xfd, 0xb6, 0x06, 0xa5, 0xc1, 0xe3, 0x9e, 0xac, 0x36, 0xbb, 0xc7, + 0x07, 0x6d, 0x19, 0xa5, 0x70, 0x05, 0x80, 0x0b, 0x1e, 0xb4, 0xbb, 0xf5, 0x01, 0x4a, 0x47, 0xe3, + 0x56, 0x67, 0x70, 0xe7, 0x16, 0xca, 0x44, 0x06, 0xc7, 0x42, 0x90, 0x8d, 0x03, 0x6e, 0xee, 0xa1, + 0x1c, 0x46, 0x50, 0x16, 0x0e, 0x5a, 0x8f, 0xe4, 0xe6, 0x9d, 0x5b, 0x28, 0x9f, 0x94, 0xdc, 0xdc, + 0x43, 0x2b, 0x78, 0x15, 0x8a, 0x5c, 0x72, 0xd0, 0xed, 0xb6, 0x51, 0x21, 0xf2, 0xd9, 0x1f, 0x28, + 0xad, 0xce, 0x21, 0x2a, 0x46, 0x3e, 0x0f, 0x95, 0xee, 0x71, 0x0f, 0x41, 0xe4, 0xe1, 0x48, 0xee, + 0xf7, 0xeb, 0x87, 0x32, 0x2a, 0x45, 0x88, 0x83, 0xc7, 0x03, 0xb9, 0x8f, 0xca, 0x89, 0xb0, 0x6e, + 0xee, 0xa1, 0xd5, 0xe8, 0x13, 0x72, 0xe7, 0xf8, 0x08, 0x55, 0xf0, 0x3a, 0xac, 0x8a, 0x4f, 0x84, + 0x41, 0xac, 0xcd, 0x88, 0xee, 0xdc, 0x42, 0x68, 0x1a, 0x88, 0xf0, 0xb2, 0x9e, 0x10, 0xdc, 0xb9, + 0x85, 0x70, 0xb5, 0x01, 0x39, 0xce, 0x2e, 0x8c, 0xa1, 0xd2, 0xae, 0x1f, 0xc8, 0x6d, 0xb5, 0xdb, + 0x1b, 0xb4, 0xba, 0x9d, 0x7a, 0x1b, 0xa5, 0xa6, 0x32, 0x45, 0xfe, 0xd5, 0x71, 0x4b, 0x91, 0x9b, + 0x28, 0x1d, 0x97, 0xf5, 0xe4, 0xfa, 0x40, 0x6e, 0xa2, 0x4c, 0x55, 0x83, 0xcd, 0x45, 0xe7, 0xcc, + 0xc2, 0x9d, 0x11, 0x5b, 0xe2, 0xf4, 0x92, 0x25, 0xe6, 0xbe, 0xe6, 0x96, 0xf8, 0xdb, 0x14, 0x6c, + 0x2c, 0x38, 0x6b, 0x17, 0x7e, 0xe4, 0x17, 0x90, 0x13, 0x14, 0x15, 0xd5, 0xe7, 0x93, 0x85, 0x87, + 0x36, 0x27, 0xec, 0x5c, 0x05, 0xe2, 0x76, 0xf1, 0x0a, 0x9c, 0x59, 0x52, 0x81, 0x99, 0x8b, 0xb9, + 0x20, 0x7f, 0x93, 0x02, 0x69, 0x99, 0xef, 0xd7, 0x1c, 0x14, 0xe9, 0xc4, 0x41, 0x71, 0x6f, 0x36, + 0x80, 0x2b, 0xcb, 0xe7, 0x30, 0x17, 0xc5, 0x77, 0x29, 0xb8, 0xb0, 0xb8, 0x51, 0x59, 0x18, 0xc3, + 0x7d, 0xc8, 0x8f, 0xa9, 0x7f, 0x6a, 0x87, 0xc5, 0xfa, 0xe3, 0x05, 0x25, 0x80, 0xa9, 0x67, 0x73, + 0x15, 0x58, 0xc5, 0x6b, 0x48, 0x66, 0x59, 0xb7, 0x21, 0xa2, 0x99, 0x8b, 0xf4, 0xb7, 0x69, 0x78, + 0x7b, 0xa1, 0xf3, 0x85, 0x81, 0xbe, 0x07, 0x60, 0x58, 0xce, 0xc4, 0x17, 0x05, 0x59, 0x9c, 0x4f, + 0x45, 0x2e, 0xe1, 0x7b, 0x9f, 0x9d, 0x3d, 0x13, 0x3f, 0xd2, 0x67, 0xb8, 0x1e, 0x84, 0x88, 0x03, + 0xee, 0x4e, 0x03, 0xcd, 0xf2, 0x40, 0xdf, 0x5f, 0x32, 0xd3, 0xb9, 0x5a, 0xf7, 0x29, 0x20, 0xcd, + 0x34, 0xa8, 0xe5, 0xab, 0x9e, 0xef, 0x52, 0x32, 0x36, 0xac, 0x11, 0x3f, 0x80, 0x0b, 0xfb, 0xb9, + 0x21, 0x31, 0x3d, 0xaa, 0xac, 0x09, 0x75, 0x3f, 0xd4, 0x32, 0x0b, 0x5e, 0x65, 0xdc, 0x98, 0x45, + 0x3e, 0x61, 0x21, 0xd4, 0x91, 0x45, 0xf5, 0xef, 0x2b, 0x50, 0x8a, 0xb5, 0x75, 0xf8, 0x0a, 0x94, + 0x9f, 0x90, 0x67, 0x44, 0x0d, 0x5b, 0x75, 0x91, 0x89, 0x12, 0x93, 0xf5, 0x82, 0x76, 0xfd, 0x53, + 0xd8, 0xe4, 0x10, 0x7b, 0xe2, 0x53, 0x57, 0xd5, 0x4c, 0xe2, 0x79, 0x3c, 0x69, 0x05, 0x0e, 0xc5, + 0x4c, 0xd7, 0x65, 0xaa, 0x46, 0xa8, 0xc1, 0xb7, 0x61, 0x83, 0x5b, 0x8c, 0x27, 0xa6, 0x6f, 0x38, + 0x26, 0x55, 0xd9, 0xe5, 0xc1, 0xe3, 0x07, 0x71, 0x14, 0xd9, 0x3a, 0x43, 0x1c, 0x05, 0x00, 0x16, + 0x91, 0x87, 0x9b, 0xf0, 0x1e, 0x37, 0x1b, 0x51, 0x8b, 0xba, 0xc4, 0xa7, 0x2a, 0xfd, 0x7a, 0x42, + 0x4c, 0x4f, 0x25, 0x96, 0xae, 0x9e, 0x12, 0xef, 0x54, 0xda, 0x64, 0x0e, 0x0e, 0xd2, 0x52, 0x4a, + 0xb9, 0xc4, 0x80, 0x87, 0x01, 0x4e, 0xe6, 0xb0, 0xba, 0xa5, 0x7f, 0x41, 0xbc, 0x53, 0xbc, 0x0f, + 0x17, 0xb8, 0x17, 0xcf, 0x77, 0x0d, 0x6b, 0xa4, 0x6a, 0xa7, 0x54, 0x7b, 0xaa, 0x4e, 0xfc, 0xe1, + 0x5d, 0xe9, 0x9d, 0xf8, 0xf7, 0x79, 0x84, 0x7d, 0x8e, 0x69, 0x30, 0xc8, 0xb1, 0x3f, 0xbc, 0x8b, + 0xfb, 0x50, 0x66, 0x8b, 0x31, 0x36, 0xbe, 0xa1, 0xea, 0xd0, 0x76, 0x79, 0x65, 0xa9, 0x2c, 0xd8, + 0xd9, 0xb1, 0x0c, 0xd6, 0xba, 0x81, 0xc1, 0x91, 0xad, 0xd3, 0xfd, 0x5c, 0xbf, 0x27, 0xcb, 0x4d, + 0xa5, 0x14, 0x7a, 0x79, 0x60, 0xbb, 0x8c, 0x50, 0x23, 0x3b, 0x4a, 0x70, 0x49, 0x10, 0x6a, 0x64, + 0x87, 0xe9, 0xbd, 0x0d, 0x1b, 0x9a, 0x26, 0xe6, 0x6c, 0x68, 0x6a, 0xd0, 0xe2, 0x7b, 0x12, 0x4a, + 0x24, 0x4b, 0xd3, 0x0e, 0x05, 0x20, 0xe0, 0xb8, 0x87, 0x3f, 0x87, 0xb7, 0xa7, 0xc9, 0x8a, 0x1b, + 0xae, 0xcf, 0xcd, 0x72, 0xd6, 0xf4, 0x36, 0x6c, 0x38, 0x67, 0xf3, 0x86, 0x38, 0xf1, 0x45, 0xe7, + 0x6c, 0xd6, 0xec, 0x23, 0x7e, 0x6d, 0x73, 0xa9, 0x46, 0x7c, 0xaa, 0x4b, 0x17, 0xe3, 0xe8, 0x98, + 0x02, 0xef, 0x02, 0xd2, 0x34, 0x95, 0x5a, 0xe4, 0xc4, 0xa4, 0x2a, 0x71, 0xa9, 0x45, 0x3c, 0xe9, + 0x72, 0x1c, 0x5c, 0xd1, 0x34, 0x99, 0x6b, 0xeb, 0x5c, 0x89, 0xaf, 0xc1, 0xba, 0x7d, 0xf2, 0x44, + 0x13, 0xcc, 0x52, 0x1d, 0x97, 0x0e, 0x8d, 0x17, 0xd2, 0x87, 0x3c, 0x4d, 0x6b, 0x4c, 0xc1, 0x79, + 0xd5, 0xe3, 0x62, 0xfc, 0x09, 0x20, 0xcd, 0x3b, 0x25, 0xae, 0xc3, 0x4b, 0xbb, 0xe7, 0x10, 0x8d, + 0x4a, 0x1f, 0x09, 0xa8, 0x90, 0x77, 0x42, 0x31, 0x63, 0xb6, 0xf7, 0xdc, 0x18, 0xfa, 0xa1, 0xc7, + 0xab, 0x82, 0xd9, 0x5c, 0x16, 0x78, 0xdb, 0x01, 0xe4, 0x9c, 0x3a, 0xc9, 0x0f, 0xef, 0x70, 0x58, + 0xc5, 0x39, 0x75, 0xe2, 0xdf, 0x7d, 0x04, 0x9b, 0x13, 0xcb, 0xb0, 0x7c, 0xea, 0x3a, 0x2e, 0x65, + 0xed, 0xbe, 0xd8, 0xb3, 0xd2, 0xbf, 0x57, 0x96, 0x34, 0xec, 0xc7, 0x71, 0xb4, 0xa0, 0x8a, 0xb2, + 0x31, 0x99, 0x17, 0x56, 0xf7, 0xa1, 0x1c, 0x67, 0x10, 0x2e, 0x82, 0xe0, 0x10, 0x4a, 0xb1, 0x6a, + 0xdc, 0xe8, 0x36, 0x59, 0x1d, 0xfd, 0x4a, 0x46, 0x69, 0x56, 0xcf, 0xdb, 0xad, 0x81, 0xac, 0x2a, + 0xc7, 0x9d, 0x41, 0xeb, 0x48, 0x46, 0x99, 0x6b, 0xc5, 0xc2, 0x7f, 0x56, 0xd0, 0xcb, 0x97, 0x2f, + 0x5f, 0xa6, 0x1f, 0x66, 0x0b, 0x1f, 0xa3, 0xab, 0xd5, 0xef, 0xd3, 0x50, 0x49, 0x76, 0xd2, 0xf8, + 0xe7, 0x70, 0x31, 0xbc, 0xf6, 0x7a, 0xd4, 0x57, 0x9f, 0x1b, 0x2e, 0xa7, 0xf6, 0x98, 0x88, 0x5e, + 0x34, 0x5a, 0x95, 0xcd, 0x00, 0xd5, 0xa7, 0xfe, 0x97, 0x86, 0xcb, 0x88, 0x3b, 0x26, 0x3e, 0x6e, + 0xc3, 0x65, 0xcb, 0x56, 0x3d, 0x9f, 0x58, 0x3a, 0x71, 0x75, 0x75, 0xfa, 0xe0, 0xa0, 0x12, 0x4d, + 0xa3, 0x9e, 0x67, 0x8b, 0x92, 0x12, 0x79, 0x79, 0xd7, 0xb2, 0xfb, 0x01, 0x78, 0x7a, 0xd6, 0xd6, + 0x03, 0xe8, 0x0c, 0x83, 0x32, 0xcb, 0x18, 0xf4, 0x0e, 0x14, 0xc7, 0xc4, 0x51, 0xa9, 0xe5, 0xbb, + 0x67, 0xbc, 0xff, 0x2b, 0x28, 0x85, 0x31, 0x71, 0x64, 0x36, 0x7e, 0x73, 0x2b, 0x91, 0xcc, 0x66, + 0x01, 0x15, 0x1f, 0x66, 0x0b, 0x45, 0x04, 0xd5, 0x7f, 0x66, 0xa0, 0x1c, 0xef, 0x07, 0x59, 0x7b, + 0xad, 0xf1, 0xb3, 0x3f, 0xc5, 0x4f, 0x87, 0x0f, 0x5e, 0xd9, 0x3d, 0xd6, 0x1a, 0xac, 0x28, 0xec, + 0xe7, 0x45, 0x97, 0xa6, 0x08, 0x4b, 0x56, 0x90, 0xd9, 0x79, 0x40, 0x45, 0xef, 0x5f, 0x50, 0x82, + 0x11, 0x3e, 0x84, 0xfc, 0x13, 0x8f, 0xfb, 0xce, 0x73, 0xdf, 0x1f, 0xbe, 0xda, 0xf7, 0xc3, 0x3e, + 0x77, 0x5e, 0x7c, 0xd8, 0x57, 0x3b, 0x5d, 0xe5, 0xa8, 0xde, 0x56, 0x02, 0x73, 0x7c, 0x09, 0xb2, + 0x26, 0xf9, 0xe6, 0x2c, 0x59, 0x3e, 0xb8, 0xe8, 0xbc, 0x8b, 0x70, 0x09, 0xb2, 0xcf, 0x29, 0x79, + 0x9a, 0x3c, 0xb4, 0xb9, 0xe8, 0x0d, 0x6e, 0x86, 0x5d, 0xc8, 0xf1, 0x7c, 0x61, 0x80, 0x20, 0x63, + 0xe8, 0x2d, 0x5c, 0x80, 0x6c, 0xa3, 0xab, 0xb0, 0x0d, 0x81, 0xa0, 0x2c, 0xa4, 0x6a, 0xaf, 0x25, + 0x37, 0x64, 0x94, 0xae, 0xde, 0x86, 0xbc, 0x48, 0x02, 0xdb, 0x2c, 0x51, 0x1a, 0xd0, 0x5b, 0xc1, + 0x30, 0xf0, 0x91, 0x0a, 0xb5, 0xc7, 0x47, 0x07, 0xb2, 0x82, 0xd2, 0xc9, 0xa5, 0xce, 0xa2, 0x5c, + 0xd5, 0x83, 0x72, 0xbc, 0x21, 0xfc, 0x51, 0x58, 0x56, 0xfd, 0x6b, 0x0a, 0x4a, 0xb1, 0x06, 0x8f, + 0xb5, 0x16, 0xc4, 0x34, 0xed, 0xe7, 0x2a, 0x31, 0x0d, 0xe2, 0x05, 0xd4, 0x00, 0x2e, 0xaa, 0x33, + 0xc9, 0x79, 0x97, 0xee, 0x47, 0xda, 0x22, 0x39, 0x94, 0xaf, 0xfe, 0x29, 0x05, 0x68, 0xb6, 0x45, + 0x9c, 0x09, 0x33, 0xf5, 0x53, 0x86, 0x59, 0xfd, 0x63, 0x0a, 0x2a, 0xc9, 0xbe, 0x70, 0x26, 0xbc, + 0x2b, 0x3f, 0x69, 0x78, 0xff, 0x48, 0xc3, 0x6a, 0xa2, 0x1b, 0x3c, 0x6f, 0x74, 0x5f, 0xc3, 0xba, + 0xa1, 0xd3, 0xb1, 0x63, 0xfb, 0xd4, 0xd2, 0xce, 0x54, 0x93, 0x3e, 0xa3, 0xa6, 0x54, 0xe5, 0x87, + 0xc6, 0xee, 0xab, 0xfb, 0xcd, 0x5a, 0x6b, 0x6a, 0xd7, 0x66, 0x66, 0xfb, 0x1b, 0xad, 0xa6, 0x7c, + 0xd4, 0xeb, 0x0e, 0xe4, 0x4e, 0xe3, 0xb1, 0x7a, 0xdc, 0xf9, 0x65, 0xa7, 0xfb, 0x65, 0x47, 0x41, + 0xc6, 0x0c, 0xec, 0x0d, 0x6e, 0xfb, 0x1e, 0xa0, 0xd9, 0xa0, 0xf0, 0x45, 0x58, 0x14, 0x16, 0x7a, + 0x0b, 0x6f, 0xc0, 0x5a, 0xa7, 0xab, 0xf6, 0x5b, 0x4d, 0x59, 0x95, 0x1f, 0x3c, 0x90, 0x1b, 0x83, + 0xbe, 0xb8, 0x80, 0x47, 0xe8, 0x41, 0x62, 0x83, 0x57, 0xff, 0x90, 0x81, 0x8d, 0x05, 0x91, 0xe0, + 0x7a, 0xd0, 0xfb, 0x8b, 0xeb, 0xc8, 0x8d, 0xf3, 0x44, 0x5f, 0x63, 0xdd, 0x45, 0x8f, 0xb8, 0x7e, + 0x70, 0x55, 0xf8, 0x04, 0x58, 0x96, 0x2c, 0xdf, 0x18, 0x1a, 0xd4, 0x0d, 0xde, 0x2b, 0xc4, 0x85, + 0x60, 0x6d, 0x2a, 0x17, 0x4f, 0x16, 0x3f, 0x03, 0xec, 0xd8, 0x9e, 0xe1, 0x1b, 0xcf, 0xa8, 0x6a, + 0x58, 0xe1, 0xe3, 0x06, 0xbb, 0x20, 0x64, 0x15, 0x14, 0x6a, 0x5a, 0x96, 0x1f, 0xa1, 0x2d, 0x3a, + 0x22, 0x33, 0x68, 0x76, 0x98, 0x67, 0x14, 0x14, 0x6a, 0x22, 0xf4, 0x15, 0x28, 0xeb, 0xf6, 0x84, + 0xb5, 0x5b, 0x02, 0xc7, 0x6a, 0x47, 0x4a, 0x29, 0x09, 0x59, 0x04, 0x09, 0xfa, 0xe1, 0xe9, 0xab, + 0x4a, 0x59, 0x29, 0x09, 0x99, 0x80, 0x5c, 0x85, 0x35, 0x32, 0x1a, 0xb9, 0xcc, 0x79, 0xe8, 0x48, + 0x74, 0xf8, 0x95, 0x48, 0xcc, 0x81, 0x5b, 0x0f, 0xa1, 0x10, 0xe6, 0x81, 0x95, 0x6a, 0x96, 0x09, + 0xd5, 0x11, 0x6f, 0x5b, 0xe9, 0x9d, 0xa2, 0x52, 0xb0, 0x42, 0xe5, 0x15, 0x28, 0x1b, 0x9e, 0x3a, + 0x7d, 0x64, 0x4d, 0x6f, 0xa7, 0x77, 0x0a, 0x4a, 0xc9, 0xf0, 0xa2, 0x57, 0xb5, 0xea, 0x77, 0x69, + 0xa8, 0x24, 0x1f, 0x89, 0x71, 0x13, 0x0a, 0xa6, 0xad, 0x11, 0x4e, 0x2d, 0xf1, 0x0b, 0xc5, 0xce, + 0x6b, 0xde, 0x95, 0x6b, 0xed, 0x00, 0xaf, 0x44, 0x96, 0x5b, 0x7f, 0x4b, 0x41, 0x21, 0x14, 0xe3, + 0x0b, 0x90, 0x75, 0x88, 0x7f, 0xca, 0xdd, 0xe5, 0x0e, 0xd2, 0x28, 0xa5, 0xf0, 0x31, 0x93, 0x7b, + 0x0e, 0xb1, 0x38, 0x05, 0x02, 0x39, 0x1b, 0xb3, 0x75, 0x35, 0x29, 0xd1, 0xf9, 0xf5, 0xc1, 0x1e, + 0x8f, 0xa9, 0xe5, 0x7b, 0xe1, 0xba, 0x06, 0xf2, 0x46, 0x20, 0xc6, 0xd7, 0x61, 0xdd, 0x77, 0x89, + 0x61, 0x26, 0xb0, 0x59, 0x8e, 0x45, 0xa1, 0x22, 0x02, 0xef, 0xc3, 0xa5, 0xd0, 0xaf, 0x4e, 0x7d, + 0xa2, 0x9d, 0x52, 0x7d, 0x6a, 0x94, 0xe7, 0x2f, 0x90, 0x17, 0x03, 0x40, 0x33, 0xd0, 0x87, 0xb6, + 0xd5, 0xef, 0x53, 0xb0, 0x1e, 0x5e, 0x78, 0xf4, 0x28, 0x59, 0x47, 0x00, 0xc4, 0xb2, 0x6c, 0x3f, + 0x9e, 0xae, 0x79, 0x2a, 0xcf, 0xd9, 0xd5, 0xea, 0x91, 0x91, 0x12, 0x73, 0xb0, 0x35, 0x06, 0x98, + 0x6a, 0x96, 0xa6, 0xed, 0x32, 0x94, 0x82, 0x5f, 0x00, 0xf8, 0xcf, 0x48, 0xe2, 0x8a, 0x0c, 0x42, + 0xc4, 0x6e, 0x46, 0x78, 0x13, 0x72, 0x27, 0x74, 0x64, 0x58, 0xc1, 0xbb, 0xa4, 0x18, 0x84, 0xaf, + 0x9d, 0xd9, 0xe8, 0xb5, 0xf3, 0xe0, 0x77, 0x29, 0xd8, 0xd0, 0xec, 0xf1, 0x6c, 0xbc, 0x07, 0x68, + 0xe6, 0x9e, 0xee, 0x7d, 0x91, 0xfa, 0xea, 0xfe, 0xc8, 0xf0, 0x4f, 0x27, 0x27, 0x35, 0xcd, 0x1e, + 0xef, 0x8e, 0x6c, 0x93, 0x58, 0xa3, 0xe9, 0xef, 0x60, 0xfc, 0x1f, 0xed, 0xc6, 0x88, 0x5a, 0x37, + 0x46, 0x76, 0xec, 0x57, 0xb1, 0x7b, 0xd3, 0x7f, 0xbf, 0x4d, 0x67, 0x0e, 0x7b, 0x07, 0x7f, 0x4e, + 0x6f, 0x1d, 0x8a, 0x6f, 0xf5, 0xc2, 0xdc, 0x28, 0x74, 0x68, 0x52, 0x8d, 0xcd, 0xf7, 0x7f, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x8e, 0x54, 0xe7, 0xef, 0x60, 0x1b, 0x00, 0x00, +} diff --git a/vendor/github.com/golang/protobuf/ptypes/any/LICENSE b/vendor/github.com/golang/protobuf/ptypes/any/LICENSE new file mode 100644 index 00000000..1b1b1921 --- /dev/null +++ b/vendor/github.com/golang/protobuf/ptypes/any/LICENSE @@ -0,0 +1,31 @@ +Go support for Protocol Buffers - Google's data interchange format + +Copyright 2010 The Go Authors. All rights reserved. +https://github.com/golang/protobuf + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go new file mode 100644 index 00000000..1fbaa44c --- /dev/null +++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go @@ -0,0 +1,168 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: github.com/golang/protobuf/ptypes/any/any.proto + +/* +Package any is a generated protocol buffer package. + +It is generated from these files: + github.com/golang/protobuf/ptypes/any/any.proto + +It has these top-level messages: + Any +*/ +package any + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// 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 + +// `Any` contains an arbitrary serialized protocol buffer message along with a +// URL that describes the type of the serialized message. +// +// Protobuf library provides support to pack/unpack Any values in the form +// of utility functions or additional generated methods of the Any type. +// +// Example 1: Pack and unpack a message in C++. +// +// Foo foo = ...; +// Any any; +// any.PackFrom(foo); +// ... +// if (any.UnpackTo(&foo)) { +// ... +// } +// +// Example 2: Pack and unpack a message in Java. +// +// Foo foo = ...; +// Any any = Any.pack(foo); +// ... +// if (any.is(Foo.class)) { +// foo = any.unpack(Foo.class); +// } +// +// Example 3: Pack and unpack a message in Python. +// +// foo = Foo(...) +// any = Any() +// any.Pack(foo) +// ... +// if any.Is(Foo.DESCRIPTOR): +// any.Unpack(foo) +// ... +// +// The pack methods provided by protobuf library will by default use +// 'type.googleapis.com/full.type.name' as the type URL and the unpack +// methods only use the fully qualified type name after the last '/' +// in the type URL, for example "foo.bar.com/x/y.z" will yield type +// name "y.z". +// +// +// JSON +// ==== +// The JSON representation of an `Any` value uses the regular +// representation of the deserialized, embedded message, with an +// additional field `@type` which contains the type URL. Example: +// +// package google.profile; +// message Person { +// string first_name = 1; +// string last_name = 2; +// } +// +// { +// "@type": "type.googleapis.com/google.profile.Person", +// "firstName": , +// "lastName": +// } +// +// If the embedded message type is well-known and has a custom JSON +// representation, that representation will be embedded adding a field +// `value` which holds the custom JSON in addition to the `@type` +// field. Example (for message [google.protobuf.Duration][]): +// +// { +// "@type": "type.googleapis.com/google.protobuf.Duration", +// "value": "1.212s" +// } +// +type Any struct { + // A URL/resource name whose content describes the type of the + // serialized protocol buffer message. + // + // For URLs which use the scheme `http`, `https`, or no scheme, the + // following restrictions and interpretations apply: + // + // * If no scheme is provided, `https` is assumed. + // * The last segment of the URL's path must represent the fully + // qualified name of the type (as in `path/google.protobuf.Duration`). + // The name should be in a canonical form (e.g., leading "." is + // not accepted). + // * An HTTP GET on the URL must yield a [google.protobuf.Type][] + // value in binary format, or produce an error. + // * Applications are allowed to cache lookup results based on the + // URL, or have them precompiled into a binary to avoid any + // lookup. Therefore, binary compatibility needs to be preserved + // on changes to types. (Use versioned type names to manage + // breaking changes.) + // + // Schemes other than `http`, `https` (or the empty scheme) might be + // used with implementation specific semantics. + // + TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl" json:"type_url,omitempty"` + // Must be a valid serialized protocol buffer of the above specified type. + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *Any) Reset() { *m = Any{} } +func (m *Any) String() string { return proto.CompactTextString(m) } +func (*Any) ProtoMessage() {} +func (*Any) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } +func (*Any) XXX_WellKnownType() string { return "Any" } + +func (m *Any) GetTypeUrl() string { + if m != nil { + return m.TypeUrl + } + return "" +} + +func (m *Any) GetValue() []byte { + if m != nil { + return m.Value + } + return nil +} + +func init() { + proto.RegisterType((*Any)(nil), "google.protobuf.Any") +} + +func init() { proto.RegisterFile("github.com/golang/protobuf/ptypes/any/any.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 184 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x4f, 0xcf, 0x2c, 0xc9, + 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28, + 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x4f, 0xcc, + 0xab, 0x04, 0x61, 0x3d, 0xb0, 0xb8, 0x10, 0x7f, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x1e, 0x4c, + 0x95, 0x92, 0x19, 0x17, 0xb3, 0x63, 0x5e, 0xa5, 0x90, 0x24, 0x17, 0x07, 0x48, 0x79, 0x7c, 0x69, + 0x51, 0x8e, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x67, 0x10, 0x3b, 0x88, 0x1f, 0x5a, 0x94, 0x23, 0x24, + 0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53, 0x9a, 0x2a, 0xc1, 0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0xe1, + 0x38, 0xe5, 0x73, 0x09, 0x27, 0xe7, 0xe7, 0xea, 0xa1, 0x19, 0xe7, 0xc4, 0xe1, 0x98, 0x57, 0x19, + 0x00, 0xe2, 0x04, 0x30, 0x46, 0xa9, 0x12, 0xe5, 0xb8, 0x45, 0x4c, 0xcc, 0xee, 0x01, 0x4e, 0xab, + 0x98, 0xe4, 0xdc, 0x21, 0x46, 0x05, 0x40, 0x95, 0xe8, 0x85, 0xa7, 0xe6, 0xe4, 0x78, 0xe7, 0xe5, + 0x97, 0xe7, 0x85, 0x80, 0x94, 0x26, 0xb1, 0x81, 0xf5, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, + 0x45, 0x1f, 0x1a, 0xf2, 0xf3, 0x00, 0x00, 0x00, +} diff --git a/vendor/manifest b/vendor/manifest index 88a7aaa5..7d0184df 100644 --- a/vendor/manifest +++ b/vendor/manifest @@ -17,6 +17,14 @@ "branch": "master", "notests": true }, + { + "importpath": "github.com/Philipp15b/go-steam", + "repository": "https://github.com/Philipp15b/go-steam", + "vcs": "git", + "revision": "e0f3bb9566e3e26411c596842288faa371e45cec", + "branch": "master", + "notests": true + }, { "importpath": "github.com/Sirupsen/logrus", "repository": "https://github.com/Sirupsen/logrus", @@ -49,6 +57,15 @@ "branch": "master", "notests": true }, + { + "importpath": "github.com/davecgh/go-spew/spew", + "repository": "https://github.com/davecgh/go-spew", + "vcs": "git", + "revision": "346938d642f2ec3594ed81d874461961cd0faa76", + "branch": "master", + "path": "/spew", + "notests": true + }, { "importpath": "github.com/dgrijalva/jwt-go", "repository": "https://github.com/dgrijalva/jwt-go", @@ -107,6 +124,33 @@ "branch": "master", "notests": true }, + { + "importpath": "github.com/golang/protobuf/proto", + "repository": "https://github.com/golang/protobuf", + "vcs": "git", + "revision": "e325f446bebc2998605911c0a2650d9920361d4a", + "branch": "master", + "path": "/proto", + "notests": true + }, + { + "importpath": "github.com/golang/protobuf/protoc-gen-go/descriptor", + "repository": "https://github.com/golang/protobuf", + "vcs": "git", + "revision": "e325f446bebc2998605911c0a2650d9920361d4a", + "branch": "master", + "path": "protoc-gen-go/descriptor", + "notests": true + }, + { + "importpath": "github.com/golang/protobuf/ptypes/any", + "repository": "https://github.com/golang/protobuf", + "vcs": "git", + "revision": "e325f446bebc2998605911c0a2650d9920361d4a", + "branch": "master", + "path": "ptypes/any", + "notests": true + }, { "importpath": "github.com/google/gops/agent", "repository": "https://github.com/google/gops",