dota_shared_enums.pb.go

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

package dota

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 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 fileDescriptor23, []int{0} }

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 fileDescriptor23, []int{1} }

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 fileDescriptor23, []int{2} }

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_2016       EEvent = 13
	EEvent_EVENT_ID_INTERNATIONAL_2016      EEvent = 14
	EEvent_EVENT_ID_COUNT                   EEvent = 15
)

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_2016",
	14: "EVENT_ID_INTERNATIONAL_2016",
	15: "EVENT_ID_COUNT",
}
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_2016":       13,
	"EVENT_ID_INTERNATIONAL_2016":      14,
	"EVENT_ID_COUNT":                   15,
}

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 fileDescriptor23, []int{3} }

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 fileDescriptor23, []int{4} }

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 fileDescriptor23, []int{5} }

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 fileDescriptor23, []int{6} }

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 fileDescriptor23, []int{7} }

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
	Fantasy_Selection_Mode_FANTASY_SELECTION_CARD_BASED     Fantasy_Selection_Mode = 9
)

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",
	9: "FANTASY_SELECTION_CARD_BASED",
}
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,
	"FANTASY_SELECTION_CARD_BASED":     9,
}

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 fileDescriptor23, []int{8} }

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
	DOTAChatChannelTypeT_DOTAChannelType_PostGame      DOTAChatChannelTypeT = 18
	DOTAChatChannelTypeT_DOTAChannelType_BattleCup     DOTAChatChannelTypeT = 19
	DOTAChatChannelTypeT_DOTAChannelType_HLTVSpectator DOTAChatChannelTypeT = 20
)

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",
	18: "DOTAChannelType_PostGame",
	19: "DOTAChannelType_BattleCup",
	20: "DOTAChannelType_HLTVSpectator",
}
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,
	"DOTAChannelType_PostGame":      18,
	"DOTAChannelType_BattleCup":     19,
	"DOTAChannelType_HLTVSpectator": 20,
}

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 fileDescriptor23, []int{9} }

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 fileDescriptor23, []int{10} }

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 fileDescriptor23, []int{11} }

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 fileDescriptor23, []int{12} }

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 fileDescriptor23, []int{13} }

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 fileDescriptor23, []int{14} }

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 fileDescriptor23, []int{15} }

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
	DOTAJoinLobbyResult_DOTA_JOIN_RESULT_TIMEOUT                       DOTAJoinLobbyResult = 11
)

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",
	11: "DOTA_JOIN_RESULT_TIMEOUT",
}
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,
	"DOTA_JOIN_RESULT_TIMEOUT":                       11,
}

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 fileDescriptor23, []int{16} }

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 fileDescriptor23, []int{17} }

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 fileDescriptor23, []int{18} }

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 fileDescriptor23, []int{19} }

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 fileDescriptor23, []int{20} }

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
	EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_GeneralSeasonalRanked EDOTAPlayerMMRType = 6
	EDOTAPlayerMMRType_k_EDOTAPlayerMMRType_SoloSeasonalRanked    EDOTAPlayerMMRType = 7
)

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",
	6: "k_EDOTAPlayerMMRType_GeneralSeasonalRanked",
	7: "k_EDOTAPlayerMMRType_SoloSeasonalRanked",
}
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,
	"k_EDOTAPlayerMMRType_GeneralSeasonalRanked": 6,
	"k_EDOTAPlayerMMRType_SoloSeasonalRanked":    7,
}

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 fileDescriptor23, []int{21} }

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
	MatchType_MATCH_TYPE_SEASONAL_RANKED   MatchType = 8
)

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

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 fileDescriptor23, []int{22} }

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 fileDescriptor23, []int{23} }

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 fileDescriptor23, []int{24} }

type ETourneyQueueDeadlineState int32

const (
	ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_Normal            ETourneyQueueDeadlineState = 0
	ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_Missed            ETourneyQueueDeadlineState = 1
	ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_ExpiredOK         ETourneyQueueDeadlineState = 2
	ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_SeekingBye        ETourneyQueueDeadlineState = 3
	ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_EligibleForRefund ETourneyQueueDeadlineState = 4
	ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_NA                ETourneyQueueDeadlineState = -1
	ETourneyQueueDeadlineState_k_ETourneyQueueDeadlineState_ExpiringSoon      ETourneyQueueDeadlineState = 101
)

var ETourneyQueueDeadlineState_name = map[int32]string{
	0:   "k_ETourneyQueueDeadlineState_Normal",
	1:   "k_ETourneyQueueDeadlineState_Missed",
	2:   "k_ETourneyQueueDeadlineState_ExpiredOK",
	3:   "k_ETourneyQueueDeadlineState_SeekingBye",
	4:   "k_ETourneyQueueDeadlineState_EligibleForRefund",
	-1:  "k_ETourneyQueueDeadlineState_NA",
	101: "k_ETourneyQueueDeadlineState_ExpiringSoon",
}
var ETourneyQueueDeadlineState_value = map[string]int32{
	"k_ETourneyQueueDeadlineState_Normal":            0,
	"k_ETourneyQueueDeadlineState_Missed":            1,
	"k_ETourneyQueueDeadlineState_ExpiredOK":         2,
	"k_ETourneyQueueDeadlineState_SeekingBye":        3,
	"k_ETourneyQueueDeadlineState_EligibleForRefund": 4,
	"k_ETourneyQueueDeadlineState_NA":                -1,
	"k_ETourneyQueueDeadlineState_ExpiringSoon":      101,
}

func (x ETourneyQueueDeadlineState) Enum() *ETourneyQueueDeadlineState {
	p := new(ETourneyQueueDeadlineState)
	*p = x
	return p
}
func (x ETourneyQueueDeadlineState) String() string {
	return proto.EnumName(ETourneyQueueDeadlineState_name, int32(x))
}
func (x *ETourneyQueueDeadlineState) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ETourneyQueueDeadlineState_value, data, "ETourneyQueueDeadlineState")
	if err != nil {
		return err
	}
	*x = ETourneyQueueDeadlineState(value)
	return nil
}
func (ETourneyQueueDeadlineState) EnumDescriptor() ([]byte, []int) { return fileDescriptor23, []int{25} }

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
	EMatchOutcome_k_EMatchOutcome_NotScored_Canceled              EMatchOutcome = 68
)

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",
	68: "k_EMatchOutcome_NotScored_Canceled",
}
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,
	"k_EMatchOutcome_NotScored_Canceled":              68,
}

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 fileDescriptor23, []int{26} }

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 fileDescriptor23, []int{0} }

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 fileDescriptor23, []int{1} }

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.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 fileDescriptor23, []int{1, 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 fileDescriptor23, []int{1, 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 fileDescriptor23, []int{1, 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
}

func init() {
	proto.RegisterType((*CDOTAClientHardwareSpecs)(nil), "dota.CDOTAClientHardwareSpecs")
	proto.RegisterType((*CDOTASaveGame)(nil), "dota.CDOTASaveGame")
	proto.RegisterType((*CDOTASaveGame_Player)(nil), "dota.CDOTASaveGame.Player")
	proto.RegisterType((*CDOTASaveGame_SaveInstance)(nil), "dota.CDOTASaveGame.SaveInstance")
	proto.RegisterType((*CDOTASaveGame_SaveInstance_PlayerPositions)(nil), "dota.CDOTASaveGame.SaveInstance.PlayerPositions")
	proto.RegisterEnum("dota.DOTA_GameMode", DOTA_GameMode_name, DOTA_GameMode_value)
	proto.RegisterEnum("dota.DOTA_GameState", DOTA_GameState_name, DOTA_GameState_value)
	proto.RegisterEnum("dota.DOTA_GC_TEAM", DOTA_GC_TEAM_name, DOTA_GC_TEAM_value)
	proto.RegisterEnum("dota.EEvent", EEvent_name, EEvent_value)
	proto.RegisterEnum("dota.DOTALeaverStatusT", DOTALeaverStatusT_name, DOTALeaverStatusT_value)
	proto.RegisterEnum("dota.DOTAConnectionStateT", DOTAConnectionStateT_name, DOTAConnectionStateT_value)
	proto.RegisterEnum("dota.Fantasy_Roles", Fantasy_Roles_name, Fantasy_Roles_value)
	proto.RegisterEnum("dota.Fantasy_Team_Slots", Fantasy_Team_Slots_name, Fantasy_Team_Slots_value)
	proto.RegisterEnum("dota.Fantasy_Selection_Mode", Fantasy_Selection_Mode_name, Fantasy_Selection_Mode_value)
	proto.RegisterEnum("dota.DOTAChatChannelTypeT", DOTAChatChannelTypeT_name, DOTAChatChannelTypeT_value)
	proto.RegisterEnum("dota.EProfileCardSlotType", EProfileCardSlotType_name, EProfileCardSlotType_value)
	proto.RegisterEnum("dota.EMatchGroupServerStatus", EMatchGroupServerStatus_name, EMatchGroupServerStatus_value)
	proto.RegisterEnum("dota.DOTA_CM_PICK", DOTA_CM_PICK_name, DOTA_CM_PICK_value)
	proto.RegisterEnum("dota.DOTALowPriorityBanType", DOTALowPriorityBanType_name, DOTALowPriorityBanType_value)
	proto.RegisterEnum("dota.DOTALobbyReadyState", DOTALobbyReadyState_name, DOTALobbyReadyState_value)
	proto.RegisterEnum("dota.DOTAGameVersion", DOTAGameVersion_name, DOTAGameVersion_value)
	proto.RegisterEnum("dota.DOTAJoinLobbyResult", DOTAJoinLobbyResult_name, DOTAJoinLobbyResult_value)
	proto.RegisterEnum("dota.SelectionPriorityType", SelectionPriorityType_name, SelectionPriorityType_value)
	proto.RegisterEnum("dota.DOTAMatchVote", DOTAMatchVote_name, DOTAMatchVote_value)
	proto.RegisterEnum("dota.DOTA_LobbyMemberXPBonus", DOTA_LobbyMemberXPBonus_name, DOTA_LobbyMemberXPBonus_value)
	proto.RegisterEnum("dota.DOTALobbyVisibility", DOTALobbyVisibility_name, DOTALobbyVisibility_value)
	proto.RegisterEnum("dota.EDOTAPlayerMMRType", EDOTAPlayerMMRType_name, EDOTAPlayerMMRType_value)
	proto.RegisterEnum("dota.MatchType", MatchType_name, MatchType_value)
	proto.RegisterEnum("dota.DOTABotDifficulty", DOTABotDifficulty_name, DOTABotDifficulty_value)
	proto.RegisterEnum("dota.MatchLanguages", MatchLanguages_name, MatchLanguages_value)
	proto.RegisterEnum("dota.ETourneyQueueDeadlineState", ETourneyQueueDeadlineState_name, ETourneyQueueDeadlineState_value)
	proto.RegisterEnum("dota.EMatchOutcome", EMatchOutcome_name, EMatchOutcome_value)
}

func init() { proto.RegisterFile("dota_shared_enums.proto", fileDescriptor23) }

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