score.pb.go

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

package api

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import encoding_binary "encoding/binary"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type Score_ScoreType int32

const (
	Score_nil        Score_ScoreType = 0
	Score_Curriculum Score_ScoreType = 1
	Score_Melee      Score_ScoreType = 2
)

var Score_ScoreType_name = map[int32]string{
	0: "ScoreType_nil",
	1: "Curriculum",
	2: "Melee",
}
var Score_ScoreType_value = map[string]int32{
	"ScoreType_nil": 0,
	"Curriculum":    1,
	"Melee":         2,
}

func (x Score_ScoreType) String() string {
	return proto.EnumName(Score_ScoreType_name, int32(x))
}
func (Score_ScoreType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_score_a39149de0dd858c1, []int{0, 0}
}

type Score struct {
	ScoreType    Score_ScoreType `protobuf:"varint,6,opt,name=score_type,json=scoreType,proto3,enum=SC2APIProtocol.Score_ScoreType" json:"score_type,omitempty"`
	Score        int32           `protobuf:"varint,7,opt,name=score,proto3" json:"score,omitempty"`
	ScoreDetails *ScoreDetails   `protobuf:"bytes,8,opt,name=score_details,json=scoreDetails" json:"score_details,omitempty"`
}

func (m *Score) Reset()         { *m = Score{} }
func (m *Score) String() string { return proto.CompactTextString(m) }
func (*Score) ProtoMessage()    {}
func (*Score) Descriptor() ([]byte, []int) {
	return fileDescriptor_score_a39149de0dd858c1, []int{0}
}
func (m *Score) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Score) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Score.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Score) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Score.Merge(dst, src)
}
func (m *Score) XXX_Size() int {
	return m.Size()
}
func (m *Score) XXX_DiscardUnknown() {
	xxx_messageInfo_Score.DiscardUnknown(m)
}

var xxx_messageInfo_Score proto.InternalMessageInfo

func (m *Score) GetScoreType() Score_ScoreType {
	if m != nil {
		return m.ScoreType
	}
	return Score_nil
}

func (m *Score) GetScore() int32 {
	if m != nil {
		return m.Score
	}
	return 0
}

func (m *Score) GetScoreDetails() *ScoreDetails {
	if m != nil {
		return m.ScoreDetails
	}
	return nil
}

type CategoryScoreDetails struct {
	None       float32 `protobuf:"fixed32,1,opt,name=none,proto3" json:"none,omitempty"`
	Army       float32 `protobuf:"fixed32,2,opt,name=army,proto3" json:"army,omitempty"`
	Economy    float32 `protobuf:"fixed32,3,opt,name=economy,proto3" json:"economy,omitempty"`
	Technology float32 `protobuf:"fixed32,4,opt,name=technology,proto3" json:"technology,omitempty"`
	Upgrade    float32 `protobuf:"fixed32,5,opt,name=upgrade,proto3" json:"upgrade,omitempty"`
}

func (m *CategoryScoreDetails) Reset()         { *m = CategoryScoreDetails{} }
func (m *CategoryScoreDetails) String() string { return proto.CompactTextString(m) }
func (*CategoryScoreDetails) ProtoMessage()    {}
func (*CategoryScoreDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_score_a39149de0dd858c1, []int{1}
}
func (m *CategoryScoreDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CategoryScoreDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CategoryScoreDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *CategoryScoreDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CategoryScoreDetails.Merge(dst, src)
}
func (m *CategoryScoreDetails) XXX_Size() int {
	return m.Size()
}
func (m *CategoryScoreDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_CategoryScoreDetails.DiscardUnknown(m)
}

var xxx_messageInfo_CategoryScoreDetails proto.InternalMessageInfo

func (m *CategoryScoreDetails) GetNone() float32 {
	if m != nil {
		return m.None
	}
	return 0
}

func (m *CategoryScoreDetails) GetArmy() float32 {
	if m != nil {
		return m.Army
	}
	return 0
}

func (m *CategoryScoreDetails) GetEconomy() float32 {
	if m != nil {
		return m.Economy
	}
	return 0
}

func (m *CategoryScoreDetails) GetTechnology() float32 {
	if m != nil {
		return m.Technology
	}
	return 0
}

func (m *CategoryScoreDetails) GetUpgrade() float32 {
	if m != nil {
		return m.Upgrade
	}
	return 0
}

type VitalScoreDetails struct {
	Life    float32 `protobuf:"fixed32,1,opt,name=life,proto3" json:"life,omitempty"`
	Shields float32 `protobuf:"fixed32,2,opt,name=shields,proto3" json:"shields,omitempty"`
	Energy  float32 `protobuf:"fixed32,3,opt,name=energy,proto3" json:"energy,omitempty"`
}

func (m *VitalScoreDetails) Reset()         { *m = VitalScoreDetails{} }
func (m *VitalScoreDetails) String() string { return proto.CompactTextString(m) }
func (*VitalScoreDetails) ProtoMessage()    {}
func (*VitalScoreDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_score_a39149de0dd858c1, []int{2}
}
func (m *VitalScoreDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VitalScoreDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VitalScoreDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *VitalScoreDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VitalScoreDetails.Merge(dst, src)
}
func (m *VitalScoreDetails) XXX_Size() int {
	return m.Size()
}
func (m *VitalScoreDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_VitalScoreDetails.DiscardUnknown(m)
}

var xxx_messageInfo_VitalScoreDetails proto.InternalMessageInfo

func (m *VitalScoreDetails) GetLife() float32 {
	if m != nil {
		return m.Life
	}
	return 0
}

func (m *VitalScoreDetails) GetShields() float32 {
	if m != nil {
		return m.Shields
	}
	return 0
}

func (m *VitalScoreDetails) GetEnergy() float32 {
	if m != nil {
		return m.Energy
	}
	return 0
}

type ScoreDetails struct {
	IdleProductionTime     float32               `protobuf:"fixed32,1,opt,name=idle_production_time,json=idleProductionTime,proto3" json:"idle_production_time,omitempty"`
	IdleWorkerTime         float32               `protobuf:"fixed32,2,opt,name=idle_worker_time,json=idleWorkerTime,proto3" json:"idle_worker_time,omitempty"`
	TotalValueUnits        float32               `protobuf:"fixed32,3,opt,name=total_value_units,json=totalValueUnits,proto3" json:"total_value_units,omitempty"`
	TotalValueStructures   float32               `protobuf:"fixed32,4,opt,name=total_value_structures,json=totalValueStructures,proto3" json:"total_value_structures,omitempty"`
	KilledValueUnits       float32               `protobuf:"fixed32,5,opt,name=killed_value_units,json=killedValueUnits,proto3" json:"killed_value_units,omitempty"`
	KilledValueStructures  float32               `protobuf:"fixed32,6,opt,name=killed_value_structures,json=killedValueStructures,proto3" json:"killed_value_structures,omitempty"`
	CollectedMinerals      float32               `protobuf:"fixed32,7,opt,name=collected_minerals,json=collectedMinerals,proto3" json:"collected_minerals,omitempty"`
	CollectedVespene       float32               `protobuf:"fixed32,8,opt,name=collected_vespene,json=collectedVespene,proto3" json:"collected_vespene,omitempty"`
	CollectionRateMinerals float32               `protobuf:"fixed32,9,opt,name=collection_rate_minerals,json=collectionRateMinerals,proto3" json:"collection_rate_minerals,omitempty"`
	CollectionRateVespene  float32               `protobuf:"fixed32,10,opt,name=collection_rate_vespene,json=collectionRateVespene,proto3" json:"collection_rate_vespene,omitempty"`
	SpentMinerals          float32               `protobuf:"fixed32,11,opt,name=spent_minerals,json=spentMinerals,proto3" json:"spent_minerals,omitempty"`
	SpentVespene           float32               `protobuf:"fixed32,12,opt,name=spent_vespene,json=spentVespene,proto3" json:"spent_vespene,omitempty"`
	FoodUsed               *CategoryScoreDetails `protobuf:"bytes,13,opt,name=food_used,json=foodUsed" json:"food_used,omitempty"`
	KilledMinerals         *CategoryScoreDetails `protobuf:"bytes,14,opt,name=killed_minerals,json=killedMinerals" json:"killed_minerals,omitempty"`
	KilledVespene          *CategoryScoreDetails `protobuf:"bytes,15,opt,name=killed_vespene,json=killedVespene" json:"killed_vespene,omitempty"`
	LostMinerals           *CategoryScoreDetails `protobuf:"bytes,16,opt,name=lost_minerals,json=lostMinerals" json:"lost_minerals,omitempty"`
	LostVespene            *CategoryScoreDetails `protobuf:"bytes,17,opt,name=lost_vespene,json=lostVespene" json:"lost_vespene,omitempty"`
	FriendlyFireMinerals   *CategoryScoreDetails `protobuf:"bytes,18,opt,name=friendly_fire_minerals,json=friendlyFireMinerals" json:"friendly_fire_minerals,omitempty"`
	FriendlyFireVespene    *CategoryScoreDetails `protobuf:"bytes,19,opt,name=friendly_fire_vespene,json=friendlyFireVespene" json:"friendly_fire_vespene,omitempty"`
	UsedMinerals           *CategoryScoreDetails `protobuf:"bytes,20,opt,name=used_minerals,json=usedMinerals" json:"used_minerals,omitempty"`
	UsedVespene            *CategoryScoreDetails `protobuf:"bytes,21,opt,name=used_vespene,json=usedVespene" json:"used_vespene,omitempty"`
	TotalUsedMinerals      *CategoryScoreDetails `protobuf:"bytes,22,opt,name=total_used_minerals,json=totalUsedMinerals" json:"total_used_minerals,omitempty"`
	TotalUsedVespene       *CategoryScoreDetails `protobuf:"bytes,23,opt,name=total_used_vespene,json=totalUsedVespene" json:"total_used_vespene,omitempty"`
	TotalDamageDealt       *VitalScoreDetails    `protobuf:"bytes,24,opt,name=total_damage_dealt,json=totalDamageDealt" json:"total_damage_dealt,omitempty"`
	TotalDamageTaken       *VitalScoreDetails    `protobuf:"bytes,25,opt,name=total_damage_taken,json=totalDamageTaken" json:"total_damage_taken,omitempty"`
	TotalHealed            *VitalScoreDetails    `protobuf:"bytes,26,opt,name=total_healed,json=totalHealed" json:"total_healed,omitempty"`
	CurrentApm             float32               `protobuf:"fixed32,27,opt,name=current_apm,json=currentApm,proto3" json:"current_apm,omitempty"`
	CurrentEffectiveApm    float32               `protobuf:"fixed32,28,opt,name=current_effective_apm,json=currentEffectiveApm,proto3" json:"current_effective_apm,omitempty"`
}

func (m *ScoreDetails) Reset()         { *m = ScoreDetails{} }
func (m *ScoreDetails) String() string { return proto.CompactTextString(m) }
func (*ScoreDetails) ProtoMessage()    {}
func (*ScoreDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_score_a39149de0dd858c1, []int{3}
}
func (m *ScoreDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ScoreDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ScoreDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *ScoreDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScoreDetails.Merge(dst, src)
}
func (m *ScoreDetails) XXX_Size() int {
	return m.Size()
}
func (m *ScoreDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_ScoreDetails.DiscardUnknown(m)
}

var xxx_messageInfo_ScoreDetails proto.InternalMessageInfo

func (m *ScoreDetails) GetIdleProductionTime() float32 {
	if m != nil {
		return m.IdleProductionTime
	}
	return 0
}

func (m *ScoreDetails) GetIdleWorkerTime() float32 {
	if m != nil {
		return m.IdleWorkerTime
	}
	return 0
}

func (m *ScoreDetails) GetTotalValueUnits() float32 {
	if m != nil {
		return m.TotalValueUnits
	}
	return 0
}

func (m *ScoreDetails) GetTotalValueStructures() float32 {
	if m != nil {
		return m.TotalValueStructures
	}
	return 0
}

func (m *ScoreDetails) GetKilledValueUnits() float32 {
	if m != nil {
		return m.KilledValueUnits
	}
	return 0
}

func (m *ScoreDetails) GetKilledValueStructures() float32 {
	if m != nil {
		return m.KilledValueStructures
	}
	return 0
}

func (m *ScoreDetails) GetCollectedMinerals() float32 {
	if m != nil {
		return m.CollectedMinerals
	}
	return 0
}

func (m *ScoreDetails) GetCollectedVespene() float32 {
	if m != nil {
		return m.CollectedVespene
	}
	return 0
}

func (m *ScoreDetails) GetCollectionRateMinerals() float32 {
	if m != nil {
		return m.CollectionRateMinerals
	}
	return 0
}

func (m *ScoreDetails) GetCollectionRateVespene() float32 {
	if m != nil {
		return m.CollectionRateVespene
	}
	return 0
}

func (m *ScoreDetails) GetSpentMinerals() float32 {
	if m != nil {
		return m.SpentMinerals
	}
	return 0
}

func (m *ScoreDetails) GetSpentVespene() float32 {
	if m != nil {
		return m.SpentVespene
	}
	return 0
}

func (m *ScoreDetails) GetFoodUsed() *CategoryScoreDetails {
	if m != nil {
		return m.FoodUsed
	}
	return nil
}

func (m *ScoreDetails) GetKilledMinerals() *CategoryScoreDetails {
	if m != nil {
		return m.KilledMinerals
	}
	return nil
}

func (m *ScoreDetails) GetKilledVespene() *CategoryScoreDetails {
	if m != nil {
		return m.KilledVespene
	}
	return nil
}

func (m *ScoreDetails) GetLostMinerals() *CategoryScoreDetails {
	if m != nil {
		return m.LostMinerals
	}
	return nil
}

func (m *ScoreDetails) GetLostVespene() *CategoryScoreDetails {
	if m != nil {
		return m.LostVespene
	}
	return nil
}

func (m *ScoreDetails) GetFriendlyFireMinerals() *CategoryScoreDetails {
	if m != nil {
		return m.FriendlyFireMinerals
	}
	return nil
}

func (m *ScoreDetails) GetFriendlyFireVespene() *CategoryScoreDetails {
	if m != nil {
		return m.FriendlyFireVespene
	}
	return nil
}

func (m *ScoreDetails) GetUsedMinerals() *CategoryScoreDetails {
	if m != nil {
		return m.UsedMinerals
	}
	return nil
}

func (m *ScoreDetails) GetUsedVespene() *CategoryScoreDetails {
	if m != nil {
		return m.UsedVespene
	}
	return nil
}

func (m *ScoreDetails) GetTotalUsedMinerals() *CategoryScoreDetails {
	if m != nil {
		return m.TotalUsedMinerals
	}
	return nil
}

func (m *ScoreDetails) GetTotalUsedVespene() *CategoryScoreDetails {
	if m != nil {
		return m.TotalUsedVespene
	}
	return nil
}

func (m *ScoreDetails) GetTotalDamageDealt() *VitalScoreDetails {
	if m != nil {
		return m.TotalDamageDealt
	}
	return nil
}

func (m *ScoreDetails) GetTotalDamageTaken() *VitalScoreDetails {
	if m != nil {
		return m.TotalDamageTaken
	}
	return nil
}

func (m *ScoreDetails) GetTotalHealed() *VitalScoreDetails {
	if m != nil {
		return m.TotalHealed
	}
	return nil
}

func (m *ScoreDetails) GetCurrentApm() float32 {
	if m != nil {
		return m.CurrentApm
	}
	return 0
}

func (m *ScoreDetails) GetCurrentEffectiveApm() float32 {
	if m != nil {
		return m.CurrentEffectiveApm
	}
	return 0
}

func init() {
	proto.RegisterType((*Score)(nil), "SC2APIProtocol.Score")
	proto.RegisterType((*CategoryScoreDetails)(nil), "SC2APIProtocol.CategoryScoreDetails")
	proto.RegisterType((*VitalScoreDetails)(nil), "SC2APIProtocol.VitalScoreDetails")
	proto.RegisterType((*ScoreDetails)(nil), "SC2APIProtocol.ScoreDetails")
	proto.RegisterEnum("SC2APIProtocol.Score_ScoreType", Score_ScoreType_name, Score_ScoreType_value)
}
func (m *Score) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Score) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ScoreType != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.ScoreType))
	}
	if m.Score != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.Score))
	}
	if m.ScoreDetails != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.ScoreDetails.Size()))
		n1, err := m.ScoreDetails.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	return i, nil
}

func (m *CategoryScoreDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CategoryScoreDetails) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.None != 0 {
		dAtA[i] = 0xd
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.None))))
		i += 4
	}
	if m.Army != 0 {
		dAtA[i] = 0x15
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Army))))
		i += 4
	}
	if m.Economy != 0 {
		dAtA[i] = 0x1d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Economy))))
		i += 4
	}
	if m.Technology != 0 {
		dAtA[i] = 0x25
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Technology))))
		i += 4
	}
	if m.Upgrade != 0 {
		dAtA[i] = 0x2d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Upgrade))))
		i += 4
	}
	return i, nil
}

func (m *VitalScoreDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VitalScoreDetails) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Life != 0 {
		dAtA[i] = 0xd
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Life))))
		i += 4
	}
	if m.Shields != 0 {
		dAtA[i] = 0x15
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Shields))))
		i += 4
	}
	if m.Energy != 0 {
		dAtA[i] = 0x1d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Energy))))
		i += 4
	}
	return i, nil
}

func (m *ScoreDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ScoreDetails) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.IdleProductionTime != 0 {
		dAtA[i] = 0xd
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.IdleProductionTime))))
		i += 4
	}
	if m.IdleWorkerTime != 0 {
		dAtA[i] = 0x15
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.IdleWorkerTime))))
		i += 4
	}
	if m.TotalValueUnits != 0 {
		dAtA[i] = 0x1d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.TotalValueUnits))))
		i += 4
	}
	if m.TotalValueStructures != 0 {
		dAtA[i] = 0x25
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.TotalValueStructures))))
		i += 4
	}
	if m.KilledValueUnits != 0 {
		dAtA[i] = 0x2d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.KilledValueUnits))))
		i += 4
	}
	if m.KilledValueStructures != 0 {
		dAtA[i] = 0x35
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.KilledValueStructures))))
		i += 4
	}
	if m.CollectedMinerals != 0 {
		dAtA[i] = 0x3d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CollectedMinerals))))
		i += 4
	}
	if m.CollectedVespene != 0 {
		dAtA[i] = 0x45
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CollectedVespene))))
		i += 4
	}
	if m.CollectionRateMinerals != 0 {
		dAtA[i] = 0x4d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CollectionRateMinerals))))
		i += 4
	}
	if m.CollectionRateVespene != 0 {
		dAtA[i] = 0x55
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CollectionRateVespene))))
		i += 4
	}
	if m.SpentMinerals != 0 {
		dAtA[i] = 0x5d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.SpentMinerals))))
		i += 4
	}
	if m.SpentVespene != 0 {
		dAtA[i] = 0x65
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.SpentVespene))))
		i += 4
	}
	if m.FoodUsed != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.FoodUsed.Size()))
		n2, err := m.FoodUsed.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.KilledMinerals != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.KilledMinerals.Size()))
		n3, err := m.KilledMinerals.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.KilledVespene != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.KilledVespene.Size()))
		n4, err := m.KilledVespene.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.LostMinerals != nil {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.LostMinerals.Size()))
		n5, err := m.LostMinerals.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.LostVespene != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.LostVespene.Size()))
		n6, err := m.LostVespene.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.FriendlyFireMinerals != nil {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.FriendlyFireMinerals.Size()))
		n7, err := m.FriendlyFireMinerals.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.FriendlyFireVespene != nil {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.FriendlyFireVespene.Size()))
		n8, err := m.FriendlyFireVespene.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.UsedMinerals != nil {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.UsedMinerals.Size()))
		n9, err := m.UsedMinerals.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.UsedVespene != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.UsedVespene.Size()))
		n10, err := m.UsedVespene.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.TotalUsedMinerals != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.TotalUsedMinerals.Size()))
		n11, err := m.TotalUsedMinerals.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.TotalUsedVespene != nil {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.TotalUsedVespene.Size()))
		n12, err := m.TotalUsedVespene.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.TotalDamageDealt != nil {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.TotalDamageDealt.Size()))
		n13, err := m.TotalDamageDealt.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if m.TotalDamageTaken != nil {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.TotalDamageTaken.Size()))
		n14, err := m.TotalDamageTaken.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.TotalHealed != nil {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintScore(dAtA, i, uint64(m.TotalHealed.Size()))
		n15, err := m.TotalHealed.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.CurrentApm != 0 {
		dAtA[i] = 0xdd
		i++
		dAtA[i] = 0x1
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CurrentApm))))
		i += 4
	}
	if m.CurrentEffectiveApm != 0 {
		dAtA[i] = 0xe5
		i++
		dAtA[i] = 0x1
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CurrentEffectiveApm))))
		i += 4
	}
	return i, nil
}

func encodeVarintScore(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Score) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ScoreType != 0 {
		n += 1 + sovScore(uint64(m.ScoreType))
	}
	if m.Score != 0 {
		n += 1 + sovScore(uint64(m.Score))
	}
	if m.ScoreDetails != nil {
		l = m.ScoreDetails.Size()
		n += 1 + l + sovScore(uint64(l))
	}
	return n
}

func (m *CategoryScoreDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.None != 0 {
		n += 5
	}
	if m.Army != 0 {
		n += 5
	}
	if m.Economy != 0 {
		n += 5
	}
	if m.Technology != 0 {
		n += 5
	}
	if m.Upgrade != 0 {
		n += 5
	}
	return n
}

func (m *VitalScoreDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Life != 0 {
		n += 5
	}
	if m.Shields != 0 {
		n += 5
	}
	if m.Energy != 0 {
		n += 5
	}
	return n
}

func (m *ScoreDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IdleProductionTime != 0 {
		n += 5
	}
	if m.IdleWorkerTime != 0 {
		n += 5
	}
	if m.TotalValueUnits != 0 {
		n += 5
	}
	if m.TotalValueStructures != 0 {
		n += 5
	}
	if m.KilledValueUnits != 0 {
		n += 5
	}
	if m.KilledValueStructures != 0 {
		n += 5
	}
	if m.CollectedMinerals != 0 {
		n += 5
	}
	if m.CollectedVespene != 0 {
		n += 5
	}
	if m.CollectionRateMinerals != 0 {
		n += 5
	}
	if m.CollectionRateVespene != 0 {
		n += 5
	}
	if m.SpentMinerals != 0 {
		n += 5
	}
	if m.SpentVespene != 0 {
		n += 5
	}
	if m.FoodUsed != nil {
		l = m.FoodUsed.Size()
		n += 1 + l + sovScore(uint64(l))
	}
	if m.KilledMinerals != nil {
		l = m.KilledMinerals.Size()
		n += 1 + l + sovScore(uint64(l))
	}
	if m.KilledVespene != nil {
		l = m.KilledVespene.Size()
		n += 1 + l + sovScore(uint64(l))
	}
	if m.LostMinerals != nil {
		l = m.LostMinerals.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.LostVespene != nil {
		l = m.LostVespene.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.FriendlyFireMinerals != nil {
		l = m.FriendlyFireMinerals.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.FriendlyFireVespene != nil {
		l = m.FriendlyFireVespene.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.UsedMinerals != nil {
		l = m.UsedMinerals.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.UsedVespene != nil {
		l = m.UsedVespene.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.TotalUsedMinerals != nil {
		l = m.TotalUsedMinerals.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.TotalUsedVespene != nil {
		l = m.TotalUsedVespene.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.TotalDamageDealt != nil {
		l = m.TotalDamageDealt.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.TotalDamageTaken != nil {
		l = m.TotalDamageTaken.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.TotalHealed != nil {
		l = m.TotalHealed.Size()
		n += 2 + l + sovScore(uint64(l))
	}
	if m.CurrentApm != 0 {
		n += 6
	}
	if m.CurrentEffectiveApm != 0 {
		n += 6
	}
	return n
}

func sovScore(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozScore(x uint64) (n int) {
	return sovScore(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Score) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowScore
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Score: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Score: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScoreType", wireType)
			}
			m.ScoreType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ScoreType |= (Score_ScoreType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
			}
			m.Score = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Score |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScoreDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ScoreDetails == nil {
				m.ScoreDetails = &ScoreDetails{}
			}
			if err := m.ScoreDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipScore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CategoryScoreDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowScore
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CategoryScoreDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CategoryScoreDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field None", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.None = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Army", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Army = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Economy", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Economy = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Technology", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Technology = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Upgrade", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Upgrade = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipScore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VitalScoreDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowScore
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VitalScoreDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VitalScoreDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Life", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Life = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shields", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Shields = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Energy", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Energy = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipScore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ScoreDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowScore
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ScoreDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScoreDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdleProductionTime", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.IdleProductionTime = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdleWorkerTime", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.IdleWorkerTime = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalValueUnits", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.TotalValueUnits = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalValueStructures", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.TotalValueStructures = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field KilledValueUnits", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.KilledValueUnits = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field KilledValueStructures", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.KilledValueStructures = float32(math.Float32frombits(v))
		case 7:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectedMinerals", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CollectedMinerals = float32(math.Float32frombits(v))
		case 8:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectedVespene", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CollectedVespene = float32(math.Float32frombits(v))
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectionRateMinerals", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CollectionRateMinerals = float32(math.Float32frombits(v))
		case 10:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectionRateVespene", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CollectionRateVespene = float32(math.Float32frombits(v))
		case 11:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpentMinerals", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.SpentMinerals = float32(math.Float32frombits(v))
		case 12:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpentVespene", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.SpentVespene = float32(math.Float32frombits(v))
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FoodUsed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FoodUsed == nil {
				m.FoodUsed = &CategoryScoreDetails{}
			}
			if err := m.FoodUsed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KilledMinerals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KilledMinerals == nil {
				m.KilledMinerals = &CategoryScoreDetails{}
			}
			if err := m.KilledMinerals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KilledVespene", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KilledVespene == nil {
				m.KilledVespene = &CategoryScoreDetails{}
			}
			if err := m.KilledVespene.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LostMinerals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LostMinerals == nil {
				m.LostMinerals = &CategoryScoreDetails{}
			}
			if err := m.LostMinerals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LostVespene", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LostVespene == nil {
				m.LostVespene = &CategoryScoreDetails{}
			}
			if err := m.LostVespene.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FriendlyFireMinerals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FriendlyFireMinerals == nil {
				m.FriendlyFireMinerals = &CategoryScoreDetails{}
			}
			if err := m.FriendlyFireMinerals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FriendlyFireVespene", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FriendlyFireVespene == nil {
				m.FriendlyFireVespene = &CategoryScoreDetails{}
			}
			if err := m.FriendlyFireVespene.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsedMinerals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UsedMinerals == nil {
				m.UsedMinerals = &CategoryScoreDetails{}
			}
			if err := m.UsedMinerals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsedVespene", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UsedVespene == nil {
				m.UsedVespene = &CategoryScoreDetails{}
			}
			if err := m.UsedVespene.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalUsedMinerals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalUsedMinerals == nil {
				m.TotalUsedMinerals = &CategoryScoreDetails{}
			}
			if err := m.TotalUsedMinerals.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalUsedVespene", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalUsedVespene == nil {
				m.TotalUsedVespene = &CategoryScoreDetails{}
			}
			if err := m.TotalUsedVespene.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalDamageDealt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalDamageDealt == nil {
				m.TotalDamageDealt = &VitalScoreDetails{}
			}
			if err := m.TotalDamageDealt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalDamageTaken", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalDamageTaken == nil {
				m.TotalDamageTaken = &VitalScoreDetails{}
			}
			if err := m.TotalDamageTaken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalHealed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowScore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthScore
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalHealed == nil {
				m.TotalHealed = &VitalScoreDetails{}
			}
			if err := m.TotalHealed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentApm", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CurrentApm = float32(math.Float32frombits(v))
		case 28:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentEffectiveApm", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.CurrentEffectiveApm = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipScore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthScore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipScore(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowScore
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowScore
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowScore
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthScore
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowScore
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipScore(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthScore = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowScore   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("score.proto", fileDescriptor_score_a39149de0dd858c1) }

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