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

package Spotify

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 Product int32

const (
	Product_PRODUCT_CLIENT              Product = 0
	Product_PRODUCT_LIBSPOTIFY          Product = 1
	Product_PRODUCT_MOBILE              Product = 2
	Product_PRODUCT_PARTNER             Product = 3
	Product_PRODUCT_LIBSPOTIFY_EMBEDDED Product = 5
)

var Product_name = map[int32]string{
	0: "PRODUCT_CLIENT",
	1: "PRODUCT_LIBSPOTIFY",
	2: "PRODUCT_MOBILE",
	3: "PRODUCT_PARTNER",
	5: "PRODUCT_LIBSPOTIFY_EMBEDDED",
}
var Product_value = map[string]int32{
	"PRODUCT_CLIENT":              0,
	"PRODUCT_LIBSPOTIFY":          1,
	"PRODUCT_MOBILE":              2,
	"PRODUCT_PARTNER":             3,
	"PRODUCT_LIBSPOTIFY_EMBEDDED": 5,
}

func (x Product) Enum() *Product {
	p := new(Product)
	*p = x
	return p
}
func (x Product) String() string {
	return proto.EnumName(Product_name, int32(x))
}
func (x *Product) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Product_value, data, "Product")
	if err != nil {
		return err
	}
	*x = Product(value)
	return nil
}
func (Product) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }

type ProductFlags int32

const (
	ProductFlags_PRODUCT_FLAG_NONE      ProductFlags = 0
	ProductFlags_PRODUCT_FLAG_DEV_BUILD ProductFlags = 1
)

var ProductFlags_name = map[int32]string{
	0: "PRODUCT_FLAG_NONE",
	1: "PRODUCT_FLAG_DEV_BUILD",
}
var ProductFlags_value = map[string]int32{
	"PRODUCT_FLAG_NONE":      0,
	"PRODUCT_FLAG_DEV_BUILD": 1,
}

func (x ProductFlags) Enum() *ProductFlags {
	p := new(ProductFlags)
	*p = x
	return p
}
func (x ProductFlags) String() string {
	return proto.EnumName(ProductFlags_name, int32(x))
}
func (x *ProductFlags) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProductFlags_value, data, "ProductFlags")
	if err != nil {
		return err
	}
	*x = ProductFlags(value)
	return nil
}
func (ProductFlags) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }

type Platform int32

const (
	Platform_PLATFORM_WIN32_X86      Platform = 0
	Platform_PLATFORM_OSX_X86        Platform = 1
	Platform_PLATFORM_LINUX_X86      Platform = 2
	Platform_PLATFORM_IPHONE_ARM     Platform = 3
	Platform_PLATFORM_S60_ARM        Platform = 4
	Platform_PLATFORM_OSX_PPC        Platform = 5
	Platform_PLATFORM_ANDROID_ARM    Platform = 6
	Platform_PLATFORM_WINDOWS_CE_ARM Platform = 7
	Platform_PLATFORM_LINUX_X86_64   Platform = 8
	Platform_PLATFORM_OSX_X86_64     Platform = 9
	Platform_PLATFORM_PALM_ARM       Platform = 10
	Platform_PLATFORM_LINUX_SH       Platform = 11
	Platform_PLATFORM_FREEBSD_X86    Platform = 12
	Platform_PLATFORM_FREEBSD_X86_64 Platform = 13
	Platform_PLATFORM_BLACKBERRY_ARM Platform = 14
	Platform_PLATFORM_SONOS          Platform = 15
	Platform_PLATFORM_LINUX_MIPS     Platform = 16
	Platform_PLATFORM_LINUX_ARM      Platform = 17
	Platform_PLATFORM_LOGITECH_ARM   Platform = 18
	Platform_PLATFORM_LINUX_BLACKFIN Platform = 19
	Platform_PLATFORM_WP7_ARM        Platform = 20
	Platform_PLATFORM_ONKYO_ARM      Platform = 21
	Platform_PLATFORM_QNXNTO_ARM     Platform = 22
	Platform_PLATFORM_BCO_ARM        Platform = 23
)

var Platform_name = map[int32]string{
	0:  "PLATFORM_WIN32_X86",
	1:  "PLATFORM_OSX_X86",
	2:  "PLATFORM_LINUX_X86",
	3:  "PLATFORM_IPHONE_ARM",
	4:  "PLATFORM_S60_ARM",
	5:  "PLATFORM_OSX_PPC",
	6:  "PLATFORM_ANDROID_ARM",
	7:  "PLATFORM_WINDOWS_CE_ARM",
	8:  "PLATFORM_LINUX_X86_64",
	9:  "PLATFORM_OSX_X86_64",
	10: "PLATFORM_PALM_ARM",
	11: "PLATFORM_LINUX_SH",
	12: "PLATFORM_FREEBSD_X86",
	13: "PLATFORM_FREEBSD_X86_64",
	14: "PLATFORM_BLACKBERRY_ARM",
	15: "PLATFORM_SONOS",
	16: "PLATFORM_LINUX_MIPS",
	17: "PLATFORM_LINUX_ARM",
	18: "PLATFORM_LOGITECH_ARM",
	19: "PLATFORM_LINUX_BLACKFIN",
	20: "PLATFORM_WP7_ARM",
	21: "PLATFORM_ONKYO_ARM",
	22: "PLATFORM_QNXNTO_ARM",
	23: "PLATFORM_BCO_ARM",
}
var Platform_value = map[string]int32{
	"PLATFORM_WIN32_X86":      0,
	"PLATFORM_OSX_X86":        1,
	"PLATFORM_LINUX_X86":      2,
	"PLATFORM_IPHONE_ARM":     3,
	"PLATFORM_S60_ARM":        4,
	"PLATFORM_OSX_PPC":        5,
	"PLATFORM_ANDROID_ARM":    6,
	"PLATFORM_WINDOWS_CE_ARM": 7,
	"PLATFORM_LINUX_X86_64":   8,
	"PLATFORM_OSX_X86_64":     9,
	"PLATFORM_PALM_ARM":       10,
	"PLATFORM_LINUX_SH":       11,
	"PLATFORM_FREEBSD_X86":    12,
	"PLATFORM_FREEBSD_X86_64": 13,
	"PLATFORM_BLACKBERRY_ARM": 14,
	"PLATFORM_SONOS":          15,
	"PLATFORM_LINUX_MIPS":     16,
	"PLATFORM_LINUX_ARM":      17,
	"PLATFORM_LOGITECH_ARM":   18,
	"PLATFORM_LINUX_BLACKFIN": 19,
	"PLATFORM_WP7_ARM":        20,
	"PLATFORM_ONKYO_ARM":      21,
	"PLATFORM_QNXNTO_ARM":     22,
	"PLATFORM_BCO_ARM":        23,
}

func (x Platform) Enum() *Platform {
	p := new(Platform)
	*p = x
	return p
}
func (x Platform) String() string {
	return proto.EnumName(Platform_name, int32(x))
}
func (x *Platform) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Platform_value, data, "Platform")
	if err != nil {
		return err
	}
	*x = Platform(value)
	return nil
}
func (Platform) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{2} }

type Fingerprint int32

const (
	Fingerprint_FINGERPRINT_GRAIN       Fingerprint = 0
	Fingerprint_FINGERPRINT_HMAC_RIPEMD Fingerprint = 1
)

var Fingerprint_name = map[int32]string{
	0: "FINGERPRINT_GRAIN",
	1: "FINGERPRINT_HMAC_RIPEMD",
}
var Fingerprint_value = map[string]int32{
	"FINGERPRINT_GRAIN":       0,
	"FINGERPRINT_HMAC_RIPEMD": 1,
}

func (x Fingerprint) Enum() *Fingerprint {
	p := new(Fingerprint)
	*p = x
	return p
}
func (x Fingerprint) String() string {
	return proto.EnumName(Fingerprint_name, int32(x))
}
func (x *Fingerprint) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Fingerprint_value, data, "Fingerprint")
	if err != nil {
		return err
	}
	*x = Fingerprint(value)
	return nil
}
func (Fingerprint) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{3} }

type Cryptosuite int32

const (
	Cryptosuite_CRYPTO_SUITE_SHANNON       Cryptosuite = 0
	Cryptosuite_CRYPTO_SUITE_RC4_SHA1_HMAC Cryptosuite = 1
)

var Cryptosuite_name = map[int32]string{
	0: "CRYPTO_SUITE_SHANNON",
	1: "CRYPTO_SUITE_RC4_SHA1_HMAC",
}
var Cryptosuite_value = map[string]int32{
	"CRYPTO_SUITE_SHANNON":       0,
	"CRYPTO_SUITE_RC4_SHA1_HMAC": 1,
}

func (x Cryptosuite) Enum() *Cryptosuite {
	p := new(Cryptosuite)
	*p = x
	return p
}
func (x Cryptosuite) String() string {
	return proto.EnumName(Cryptosuite_name, int32(x))
}
func (x *Cryptosuite) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Cryptosuite_value, data, "Cryptosuite")
	if err != nil {
		return err
	}
	*x = Cryptosuite(value)
	return nil
}
func (Cryptosuite) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{4} }

type Powscheme int32

const (
	Powscheme_POW_HASH_CASH Powscheme = 0
)

var Powscheme_name = map[int32]string{
	0: "POW_HASH_CASH",
}
var Powscheme_value = map[string]int32{
	"POW_HASH_CASH": 0,
}

func (x Powscheme) Enum() *Powscheme {
	p := new(Powscheme)
	*p = x
	return p
}
func (x Powscheme) String() string {
	return proto.EnumName(Powscheme_name, int32(x))
}
func (x *Powscheme) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Powscheme_value, data, "Powscheme")
	if err != nil {
		return err
	}
	*x = Powscheme(value)
	return nil
}
func (Powscheme) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{5} }

type ErrorCode int32

const (
	ErrorCode_ProtocolError               ErrorCode = 0
	ErrorCode_TryAnotherAP                ErrorCode = 2
	ErrorCode_BadConnectionId             ErrorCode = 5
	ErrorCode_TravelRestriction           ErrorCode = 9
	ErrorCode_PremiumAccountRequired      ErrorCode = 11
	ErrorCode_BadCredentials              ErrorCode = 12
	ErrorCode_CouldNotValidateCredentials ErrorCode = 13
	ErrorCode_AccountExists               ErrorCode = 14
	ErrorCode_ExtraVerificationRequired   ErrorCode = 15
	ErrorCode_InvalidAppKey               ErrorCode = 16
	ErrorCode_ApplicationBanned           ErrorCode = 17
)

var ErrorCode_name = map[int32]string{
	0:  "ProtocolError",
	2:  "TryAnotherAP",
	5:  "BadConnectionId",
	9:  "TravelRestriction",
	11: "PremiumAccountRequired",
	12: "BadCredentials",
	13: "CouldNotValidateCredentials",
	14: "AccountExists",
	15: "ExtraVerificationRequired",
	16: "InvalidAppKey",
	17: "ApplicationBanned",
}
var ErrorCode_value = map[string]int32{
	"ProtocolError":               0,
	"TryAnotherAP":                2,
	"BadConnectionId":             5,
	"TravelRestriction":           9,
	"PremiumAccountRequired":      11,
	"BadCredentials":              12,
	"CouldNotValidateCredentials": 13,
	"AccountExists":               14,
	"ExtraVerificationRequired":   15,
	"InvalidAppKey":               16,
	"ApplicationBanned":           17,
}

func (x ErrorCode) Enum() *ErrorCode {
	p := new(ErrorCode)
	*p = x
	return p
}
func (x ErrorCode) String() string {
	return proto.EnumName(ErrorCode_name, int32(x))
}
func (x *ErrorCode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ErrorCode_value, data, "ErrorCode")
	if err != nil {
		return err
	}
	*x = ErrorCode(value)
	return nil
}
func (ErrorCode) EnumDescriptor() ([]byte, []int) { return fileDescriptor4, []int{6} }

type ClientHello struct {
	BuildInfo             *BuildInfo             `protobuf:"bytes,10,req,name=build_info,json=buildInfo" json:"build_info,omitempty"`
	FingerprintsSupported []Fingerprint          `protobuf:"varint,20,rep,name=fingerprints_supported,json=fingerprintsSupported,enum=Spotify.Fingerprint" json:"fingerprints_supported,omitempty"`
	CryptosuitesSupported []Cryptosuite          `protobuf:"varint,30,rep,name=cryptosuites_supported,json=cryptosuitesSupported,enum=Spotify.Cryptosuite" json:"cryptosuites_supported,omitempty"`
	PowschemesSupported   []Powscheme            `protobuf:"varint,40,rep,name=powschemes_supported,json=powschemesSupported,enum=Spotify.Powscheme" json:"powschemes_supported,omitempty"`
	LoginCryptoHello      *LoginCryptoHelloUnion `protobuf:"bytes,50,req,name=login_crypto_hello,json=loginCryptoHello" json:"login_crypto_hello,omitempty"`
	ClientNonce           []byte                 `protobuf:"bytes,60,req,name=client_nonce,json=clientNonce" json:"client_nonce,omitempty"`
	Padding               []byte                 `protobuf:"bytes,70,opt,name=padding" json:"padding,omitempty"`
	FeatureSet            *FeatureSet            `protobuf:"bytes,80,opt,name=feature_set,json=featureSet" json:"feature_set,omitempty"`
	XXX_unrecognized      []byte                 `json:"-"`
}

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

func (m *ClientHello) GetBuildInfo() *BuildInfo {
	if m != nil {
		return m.BuildInfo
	}
	return nil
}

func (m *ClientHello) GetFingerprintsSupported() []Fingerprint {
	if m != nil {
		return m.FingerprintsSupported
	}
	return nil
}

func (m *ClientHello) GetCryptosuitesSupported() []Cryptosuite {
	if m != nil {
		return m.CryptosuitesSupported
	}
	return nil
}

func (m *ClientHello) GetPowschemesSupported() []Powscheme {
	if m != nil {
		return m.PowschemesSupported
	}
	return nil
}

func (m *ClientHello) GetLoginCryptoHello() *LoginCryptoHelloUnion {
	if m != nil {
		return m.LoginCryptoHello
	}
	return nil
}

func (m *ClientHello) GetClientNonce() []byte {
	if m != nil {
		return m.ClientNonce
	}
	return nil
}

func (m *ClientHello) GetPadding() []byte {
	if m != nil {
		return m.Padding
	}
	return nil
}

func (m *ClientHello) GetFeatureSet() *FeatureSet {
	if m != nil {
		return m.FeatureSet
	}
	return nil
}

type BuildInfo struct {
	Product          *Product       `protobuf:"varint,10,req,name=product,enum=Spotify.Product" json:"product,omitempty"`
	ProductFlags     []ProductFlags `protobuf:"varint,20,rep,name=product_flags,json=productFlags,enum=Spotify.ProductFlags" json:"product_flags,omitempty"`
	Platform         *Platform      `protobuf:"varint,30,req,name=platform,enum=Spotify.Platform" json:"platform,omitempty"`
	Version          *uint64        `protobuf:"varint,40,req,name=version" json:"version,omitempty"`
	XXX_unrecognized []byte         `json:"-"`
}

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

func (m *BuildInfo) GetProduct() Product {
	if m != nil && m.Product != nil {
		return *m.Product
	}
	return Product_PRODUCT_CLIENT
}

func (m *BuildInfo) GetProductFlags() []ProductFlags {
	if m != nil {
		return m.ProductFlags
	}
	return nil
}

func (m *BuildInfo) GetPlatform() Platform {
	if m != nil && m.Platform != nil {
		return *m.Platform
	}
	return Platform_PLATFORM_WIN32_X86
}

func (m *BuildInfo) GetVersion() uint64 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return 0
}

type LoginCryptoHelloUnion struct {
	DiffieHellman    *LoginCryptoDiffieHellmanHello `protobuf:"bytes,10,opt,name=diffie_hellman,json=diffieHellman" json:"diffie_hellman,omitempty"`
	XXX_unrecognized []byte                         `json:"-"`
}

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

func (m *LoginCryptoHelloUnion) GetDiffieHellman() *LoginCryptoDiffieHellmanHello {
	if m != nil {
		return m.DiffieHellman
	}
	return nil
}

type LoginCryptoDiffieHellmanHello struct {
	Gc               []byte  `protobuf:"bytes,10,req,name=gc" json:"gc,omitempty"`
	ServerKeysKnown  *uint32 `protobuf:"varint,20,req,name=server_keys_known,json=serverKeysKnown" json:"server_keys_known,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *LoginCryptoDiffieHellmanHello) GetGc() []byte {
	if m != nil {
		return m.Gc
	}
	return nil
}

func (m *LoginCryptoDiffieHellmanHello) GetServerKeysKnown() uint32 {
	if m != nil && m.ServerKeysKnown != nil {
		return *m.ServerKeysKnown
	}
	return 0
}

type FeatureSet struct {
	Autoupdate2      *bool  `protobuf:"varint,1,opt,name=autoupdate2" json:"autoupdate2,omitempty"`
	CurrentLocation  *bool  `protobuf:"varint,2,opt,name=current_location,json=currentLocation" json:"current_location,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *FeatureSet) GetAutoupdate2() bool {
	if m != nil && m.Autoupdate2 != nil {
		return *m.Autoupdate2
	}
	return false
}

func (m *FeatureSet) GetCurrentLocation() bool {
	if m != nil && m.CurrentLocation != nil {
		return *m.CurrentLocation
	}
	return false
}

type APResponseMessage struct {
	Challenge        *APChallenge            `protobuf:"bytes,10,opt,name=challenge" json:"challenge,omitempty"`
	Upgrade          *UpgradeRequiredMessage `protobuf:"bytes,20,opt,name=upgrade" json:"upgrade,omitempty"`
	LoginFailed      *APLoginFailed          `protobuf:"bytes,30,opt,name=login_failed,json=loginFailed" json:"login_failed,omitempty"`
	XXX_unrecognized []byte                  `json:"-"`
}

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

func (m *APResponseMessage) GetChallenge() *APChallenge {
	if m != nil {
		return m.Challenge
	}
	return nil
}

func (m *APResponseMessage) GetUpgrade() *UpgradeRequiredMessage {
	if m != nil {
		return m.Upgrade
	}
	return nil
}

func (m *APResponseMessage) GetLoginFailed() *APLoginFailed {
	if m != nil {
		return m.LoginFailed
	}
	return nil
}

type APChallenge struct {
	LoginCryptoChallenge *LoginCryptoChallengeUnion `protobuf:"bytes,10,req,name=login_crypto_challenge,json=loginCryptoChallenge" json:"login_crypto_challenge,omitempty"`
	FingerprintChallenge *FingerprintChallengeUnion `protobuf:"bytes,20,req,name=fingerprint_challenge,json=fingerprintChallenge" json:"fingerprint_challenge,omitempty"`
	PowChallenge         *PoWChallengeUnion         `protobuf:"bytes,30,req,name=pow_challenge,json=powChallenge" json:"pow_challenge,omitempty"`
	CryptoChallenge      *CryptoChallengeUnion      `protobuf:"bytes,40,req,name=crypto_challenge,json=cryptoChallenge" json:"crypto_challenge,omitempty"`
	ServerNonce          []byte                     `protobuf:"bytes,50,req,name=server_nonce,json=serverNonce" json:"server_nonce,omitempty"`
	Padding              []byte                     `protobuf:"bytes,60,opt,name=padding" json:"padding,omitempty"`
	XXX_unrecognized     []byte                     `json:"-"`
}

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

func (m *APChallenge) GetLoginCryptoChallenge() *LoginCryptoChallengeUnion {
	if m != nil {
		return m.LoginCryptoChallenge
	}
	return nil
}

func (m *APChallenge) GetFingerprintChallenge() *FingerprintChallengeUnion {
	if m != nil {
		return m.FingerprintChallenge
	}
	return nil
}

func (m *APChallenge) GetPowChallenge() *PoWChallengeUnion {
	if m != nil {
		return m.PowChallenge
	}
	return nil
}

func (m *APChallenge) GetCryptoChallenge() *CryptoChallengeUnion {
	if m != nil {
		return m.CryptoChallenge
	}
	return nil
}

func (m *APChallenge) GetServerNonce() []byte {
	if m != nil {
		return m.ServerNonce
	}
	return nil
}

func (m *APChallenge) GetPadding() []byte {
	if m != nil {
		return m.Padding
	}
	return nil
}

type LoginCryptoChallengeUnion struct {
	DiffieHellman    *LoginCryptoDiffieHellmanChallenge `protobuf:"bytes,10,opt,name=diffie_hellman,json=diffieHellman" json:"diffie_hellman,omitempty"`
	XXX_unrecognized []byte                             `json:"-"`
}

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

func (m *LoginCryptoChallengeUnion) GetDiffieHellman() *LoginCryptoDiffieHellmanChallenge {
	if m != nil {
		return m.DiffieHellman
	}
	return nil
}

type LoginCryptoDiffieHellmanChallenge struct {
	Gs                 []byte `protobuf:"bytes,10,req,name=gs" json:"gs,omitempty"`
	ServerSignatureKey *int32 `protobuf:"varint,20,req,name=server_signature_key,json=serverSignatureKey" json:"server_signature_key,omitempty"`
	GsSignature        []byte `protobuf:"bytes,30,req,name=gs_signature,json=gsSignature" json:"gs_signature,omitempty"`
	XXX_unrecognized   []byte `json:"-"`
}

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

func (m *LoginCryptoDiffieHellmanChallenge) GetGs() []byte {
	if m != nil {
		return m.Gs
	}
	return nil
}

func (m *LoginCryptoDiffieHellmanChallenge) GetServerSignatureKey() int32 {
	if m != nil && m.ServerSignatureKey != nil {
		return *m.ServerSignatureKey
	}
	return 0
}

func (m *LoginCryptoDiffieHellmanChallenge) GetGsSignature() []byte {
	if m != nil {
		return m.GsSignature
	}
	return nil
}

type FingerprintChallengeUnion struct {
	Grain            *FingerprintGrainChallenge      `protobuf:"bytes,10,opt,name=grain" json:"grain,omitempty"`
	HmacRipemd       *FingerprintHmacRipemdChallenge `protobuf:"bytes,20,opt,name=hmac_ripemd,json=hmacRipemd" json:"hmac_ripemd,omitempty"`
	XXX_unrecognized []byte                          `json:"-"`
}

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

func (m *FingerprintChallengeUnion) GetGrain() *FingerprintGrainChallenge {
	if m != nil {
		return m.Grain
	}
	return nil
}

func (m *FingerprintChallengeUnion) GetHmacRipemd() *FingerprintHmacRipemdChallenge {
	if m != nil {
		return m.HmacRipemd
	}
	return nil
}

type FingerprintGrainChallenge struct {
	Kek              []byte `protobuf:"bytes,10,req,name=kek" json:"kek,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *FingerprintGrainChallenge) GetKek() []byte {
	if m != nil {
		return m.Kek
	}
	return nil
}

type FingerprintHmacRipemdChallenge struct {
	Challenge        []byte `protobuf:"bytes,10,req,name=challenge" json:"challenge,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *FingerprintHmacRipemdChallenge) GetChallenge() []byte {
	if m != nil {
		return m.Challenge
	}
	return nil
}

type PoWChallengeUnion struct {
	HashCash         *PoWHashCashChallenge `protobuf:"bytes,10,opt,name=hash_cash,json=hashCash" json:"hash_cash,omitempty"`
	XXX_unrecognized []byte                `json:"-"`
}

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

func (m *PoWChallengeUnion) GetHashCash() *PoWHashCashChallenge {
	if m != nil {
		return m.HashCash
	}
	return nil
}

type PoWHashCashChallenge struct {
	Prefix           []byte `protobuf:"bytes,10,opt,name=prefix" json:"prefix,omitempty"`
	Length           *int32 `protobuf:"varint,20,opt,name=length" json:"length,omitempty"`
	Target           *int32 `protobuf:"varint,30,opt,name=target" json:"target,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *PoWHashCashChallenge) GetPrefix() []byte {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *PoWHashCashChallenge) GetLength() int32 {
	if m != nil && m.Length != nil {
		return *m.Length
	}
	return 0
}

func (m *PoWHashCashChallenge) GetTarget() int32 {
	if m != nil && m.Target != nil {
		return *m.Target
	}
	return 0
}

type CryptoChallengeUnion struct {
	Shannon          *CryptoShannonChallenge     `protobuf:"bytes,10,opt,name=shannon" json:"shannon,omitempty"`
	Rc4Sha1Hmac      *CryptoRc4Sha1HmacChallenge `protobuf:"bytes,20,opt,name=rc4_sha1_hmac,json=rc4Sha1Hmac" json:"rc4_sha1_hmac,omitempty"`
	XXX_unrecognized []byte                      `json:"-"`
}

func (m *CryptoChallengeUnion) Reset()                    { *m = CryptoChallengeUnion{} }
func (m *CryptoChallengeUnion) String() string            { return proto.CompactTextString(m) }
func (*CryptoChallengeUnion) ProtoMessage()               {}
func (*CryptoChallengeUnion) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{14} }

func (m *CryptoChallengeUnion) GetShannon() *CryptoShannonChallenge {
	if m != nil {
		return m.Shannon
	}
	return nil
}

func (m *CryptoChallengeUnion) GetRc4Sha1Hmac() *CryptoRc4Sha1HmacChallenge {
	if m != nil {
		return m.Rc4Sha1Hmac
	}
	return nil
}

type CryptoShannonChallenge struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *CryptoShannonChallenge) Reset()                    { *m = CryptoShannonChallenge{} }
func (m *CryptoShannonChallenge) String() string            { return proto.CompactTextString(m) }
func (*CryptoShannonChallenge) ProtoMessage()               {}
func (*CryptoShannonChallenge) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{15} }

type CryptoRc4Sha1HmacChallenge struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *CryptoRc4Sha1HmacChallenge) Reset()                    { *m = CryptoRc4Sha1HmacChallenge{} }
func (m *CryptoRc4Sha1HmacChallenge) String() string            { return proto.CompactTextString(m) }
func (*CryptoRc4Sha1HmacChallenge) ProtoMessage()               {}
func (*CryptoRc4Sha1HmacChallenge) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{16} }

type UpgradeRequiredMessage struct {
	UpgradeSignedPart []byte  `protobuf:"bytes,10,req,name=upgrade_signed_part,json=upgradeSignedPart" json:"upgrade_signed_part,omitempty"`
	Signature         []byte  `protobuf:"bytes,20,req,name=signature" json:"signature,omitempty"`
	HttpSuffix        *string `protobuf:"bytes,30,opt,name=http_suffix,json=httpSuffix" json:"http_suffix,omitempty"`
	XXX_unrecognized  []byte  `json:"-"`
}

func (m *UpgradeRequiredMessage) Reset()                    { *m = UpgradeRequiredMessage{} }
func (m *UpgradeRequiredMessage) String() string            { return proto.CompactTextString(m) }
func (*UpgradeRequiredMessage) ProtoMessage()               {}
func (*UpgradeRequiredMessage) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{17} }

func (m *UpgradeRequiredMessage) GetUpgradeSignedPart() []byte {
	if m != nil {
		return m.UpgradeSignedPart
	}
	return nil
}

func (m *UpgradeRequiredMessage) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *UpgradeRequiredMessage) GetHttpSuffix() string {
	if m != nil && m.HttpSuffix != nil {
		return *m.HttpSuffix
	}
	return ""
}

type APLoginFailed struct {
	ErrorCode        *ErrorCode `protobuf:"varint,10,req,name=error_code,json=errorCode,enum=Spotify.ErrorCode" json:"error_code,omitempty"`
	RetryDelay       *int32     `protobuf:"varint,20,opt,name=retry_delay,json=retryDelay" json:"retry_delay,omitempty"`
	Expiry           *int32     `protobuf:"varint,30,opt,name=expiry" json:"expiry,omitempty"`
	ErrorDescription *string    `protobuf:"bytes,40,opt,name=error_description,json=errorDescription" json:"error_description,omitempty"`
	XXX_unrecognized []byte     `json:"-"`
}

func (m *APLoginFailed) Reset()                    { *m = APLoginFailed{} }
func (m *APLoginFailed) String() string            { return proto.CompactTextString(m) }
func (*APLoginFailed) ProtoMessage()               {}
func (*APLoginFailed) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{18} }

func (m *APLoginFailed) GetErrorCode() ErrorCode {
	if m != nil && m.ErrorCode != nil {
		return *m.ErrorCode
	}
	return ErrorCode_ProtocolError
}

func (m *APLoginFailed) GetRetryDelay() int32 {
	if m != nil && m.RetryDelay != nil {
		return *m.RetryDelay
	}
	return 0
}

func (m *APLoginFailed) GetExpiry() int32 {
	if m != nil && m.Expiry != nil {
		return *m.Expiry
	}
	return 0
}

func (m *APLoginFailed) GetErrorDescription() string {
	if m != nil && m.ErrorDescription != nil {
		return *m.ErrorDescription
	}
	return ""
}

type ClientResponsePlaintext struct {
	LoginCryptoResponse *LoginCryptoResponseUnion `protobuf:"bytes,10,req,name=login_crypto_response,json=loginCryptoResponse" json:"login_crypto_response,omitempty"`
	PowResponse         *PoWResponseUnion         `protobuf:"bytes,20,req,name=pow_response,json=powResponse" json:"pow_response,omitempty"`
	CryptoResponse      *CryptoResponseUnion      `protobuf:"bytes,30,req,name=crypto_response,json=cryptoResponse" json:"crypto_response,omitempty"`
	XXX_unrecognized    []byte                    `json:"-"`
}

func (m *ClientResponsePlaintext) Reset()                    { *m = ClientResponsePlaintext{} }
func (m *ClientResponsePlaintext) String() string            { return proto.CompactTextString(m) }
func (*ClientResponsePlaintext) ProtoMessage()               {}
func (*ClientResponsePlaintext) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{19} }

func (m *ClientResponsePlaintext) GetLoginCryptoResponse() *LoginCryptoResponseUnion {
	if m != nil {
		return m.LoginCryptoResponse
	}
	return nil
}

func (m *ClientResponsePlaintext) GetPowResponse() *PoWResponseUnion {
	if m != nil {
		return m.PowResponse
	}
	return nil
}

func (m *ClientResponsePlaintext) GetCryptoResponse() *CryptoResponseUnion {
	if m != nil {
		return m.CryptoResponse
	}
	return nil
}

type LoginCryptoResponseUnion struct {
	DiffieHellman    *LoginCryptoDiffieHellmanResponse `protobuf:"bytes,10,opt,name=diffie_hellman,json=diffieHellman" json:"diffie_hellman,omitempty"`
	XXX_unrecognized []byte                            `json:"-"`
}

func (m *LoginCryptoResponseUnion) Reset()                    { *m = LoginCryptoResponseUnion{} }
func (m *LoginCryptoResponseUnion) String() string            { return proto.CompactTextString(m) }
func (*LoginCryptoResponseUnion) ProtoMessage()               {}
func (*LoginCryptoResponseUnion) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{20} }

func (m *LoginCryptoResponseUnion) GetDiffieHellman() *LoginCryptoDiffieHellmanResponse {
	if m != nil {
		return m.DiffieHellman
	}
	return nil
}

type LoginCryptoDiffieHellmanResponse struct {
	Hmac             []byte `protobuf:"bytes,10,req,name=hmac" json:"hmac,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *LoginCryptoDiffieHellmanResponse) Reset()         { *m = LoginCryptoDiffieHellmanResponse{} }
func (m *LoginCryptoDiffieHellmanResponse) String() string { return proto.CompactTextString(m) }
func (*LoginCryptoDiffieHellmanResponse) ProtoMessage()    {}
func (*LoginCryptoDiffieHellmanResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor4, []int{21}
}

func (m *LoginCryptoDiffieHellmanResponse) GetHmac() []byte {
	if m != nil {
		return m.Hmac
	}
	return nil
}

type PoWResponseUnion struct {
	HashCash         *PoWHashCashResponse `protobuf:"bytes,10,opt,name=hash_cash,json=hashCash" json:"hash_cash,omitempty"`
	XXX_unrecognized []byte               `json:"-"`
}

func (m *PoWResponseUnion) Reset()                    { *m = PoWResponseUnion{} }
func (m *PoWResponseUnion) String() string            { return proto.CompactTextString(m) }
func (*PoWResponseUnion) ProtoMessage()               {}
func (*PoWResponseUnion) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{22} }

func (m *PoWResponseUnion) GetHashCash() *PoWHashCashResponse {
	if m != nil {
		return m.HashCash
	}
	return nil
}

type PoWHashCashResponse struct {
	HashSuffix       []byte `protobuf:"bytes,10,req,name=hash_suffix,json=hashSuffix" json:"hash_suffix,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *PoWHashCashResponse) Reset()                    { *m = PoWHashCashResponse{} }
func (m *PoWHashCashResponse) String() string            { return proto.CompactTextString(m) }
func (*PoWHashCashResponse) ProtoMessage()               {}
func (*PoWHashCashResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{23} }

func (m *PoWHashCashResponse) GetHashSuffix() []byte {
	if m != nil {
		return m.HashSuffix
	}
	return nil
}

type CryptoResponseUnion struct {
	Shannon          *CryptoShannonResponse     `protobuf:"bytes,10,opt,name=shannon" json:"shannon,omitempty"`
	Rc4Sha1Hmac      *CryptoRc4Sha1HmacResponse `protobuf:"bytes,20,opt,name=rc4_sha1_hmac,json=rc4Sha1Hmac" json:"rc4_sha1_hmac,omitempty"`
	XXX_unrecognized []byte                     `json:"-"`
}

func (m *CryptoResponseUnion) Reset()                    { *m = CryptoResponseUnion{} }
func (m *CryptoResponseUnion) String() string            { return proto.CompactTextString(m) }
func (*CryptoResponseUnion) ProtoMessage()               {}
func (*CryptoResponseUnion) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{24} }

func (m *CryptoResponseUnion) GetShannon() *CryptoShannonResponse {
	if m != nil {
		return m.Shannon
	}
	return nil
}

func (m *CryptoResponseUnion) GetRc4Sha1Hmac() *CryptoRc4Sha1HmacResponse {
	if m != nil {
		return m.Rc4Sha1Hmac
	}
	return nil
}

type CryptoShannonResponse struct {
	Dummy            *int32 `protobuf:"varint,1,opt,name=dummy" json:"dummy,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *CryptoShannonResponse) Reset()                    { *m = CryptoShannonResponse{} }
func (m *CryptoShannonResponse) String() string            { return proto.CompactTextString(m) }
func (*CryptoShannonResponse) ProtoMessage()               {}
func (*CryptoShannonResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{25} }

func (m *CryptoShannonResponse) GetDummy() int32 {
	if m != nil && m.Dummy != nil {
		return *m.Dummy
	}
	return 0
}

type CryptoRc4Sha1HmacResponse struct {
	Dummy            *int32 `protobuf:"varint,1,opt,name=dummy" json:"dummy,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *CryptoRc4Sha1HmacResponse) Reset()                    { *m = CryptoRc4Sha1HmacResponse{} }
func (m *CryptoRc4Sha1HmacResponse) String() string            { return proto.CompactTextString(m) }
func (*CryptoRc4Sha1HmacResponse) ProtoMessage()               {}
func (*CryptoRc4Sha1HmacResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{26} }

func (m *CryptoRc4Sha1HmacResponse) GetDummy() int32 {
	if m != nil && m.Dummy != nil {
		return *m.Dummy
	}
	return 0
}

func init() {
	proto.RegisterType((*ClientHello)(nil), "Spotify.ClientHello")
	proto.RegisterType((*BuildInfo)(nil), "Spotify.BuildInfo")
	proto.RegisterType((*LoginCryptoHelloUnion)(nil), "Spotify.LoginCryptoHelloUnion")
	proto.RegisterType((*LoginCryptoDiffieHellmanHello)(nil), "Spotify.LoginCryptoDiffieHellmanHello")
	proto.RegisterType((*FeatureSet)(nil), "Spotify.FeatureSet")
	proto.RegisterType((*APResponseMessage)(nil), "Spotify.APResponseMessage")
	proto.RegisterType((*APChallenge)(nil), "Spotify.APChallenge")
	proto.RegisterType((*LoginCryptoChallengeUnion)(nil), "Spotify.LoginCryptoChallengeUnion")
	proto.RegisterType((*LoginCryptoDiffieHellmanChallenge)(nil), "Spotify.LoginCryptoDiffieHellmanChallenge")
	proto.RegisterType((*FingerprintChallengeUnion)(nil), "Spotify.FingerprintChallengeUnion")
	proto.RegisterType((*FingerprintGrainChallenge)(nil), "Spotify.FingerprintGrainChallenge")
	proto.RegisterType((*FingerprintHmacRipemdChallenge)(nil), "Spotify.FingerprintHmacRipemdChallenge")
	proto.RegisterType((*PoWChallengeUnion)(nil), "Spotify.PoWChallengeUnion")
	proto.RegisterType((*PoWHashCashChallenge)(nil), "Spotify.PoWHashCashChallenge")
	proto.RegisterType((*CryptoChallengeUnion)(nil), "Spotify.CryptoChallengeUnion")
	proto.RegisterType((*CryptoShannonChallenge)(nil), "Spotify.CryptoShannonChallenge")
	proto.RegisterType((*CryptoRc4Sha1HmacChallenge)(nil), "Spotify.CryptoRc4Sha1HmacChallenge")
	proto.RegisterType((*UpgradeRequiredMessage)(nil), "Spotify.UpgradeRequiredMessage")
	proto.RegisterType((*APLoginFailed)(nil), "Spotify.APLoginFailed")
	proto.RegisterType((*ClientResponsePlaintext)(nil), "Spotify.ClientResponsePlaintext")
	proto.RegisterType((*LoginCryptoResponseUnion)(nil), "Spotify.LoginCryptoResponseUnion")
	proto.RegisterType((*LoginCryptoDiffieHellmanResponse)(nil), "Spotify.LoginCryptoDiffieHellmanResponse")
	proto.RegisterType((*PoWResponseUnion)(nil), "Spotify.PoWResponseUnion")
	proto.RegisterType((*PoWHashCashResponse)(nil), "Spotify.PoWHashCashResponse")
	proto.RegisterType((*CryptoResponseUnion)(nil), "Spotify.CryptoResponseUnion")
	proto.RegisterType((*CryptoShannonResponse)(nil), "Spotify.CryptoShannonResponse")
	proto.RegisterType((*CryptoRc4Sha1HmacResponse)(nil), "Spotify.CryptoRc4Sha1HmacResponse")
	proto.RegisterEnum("Spotify.Product", Product_name, Product_value)
	proto.RegisterEnum("Spotify.ProductFlags", ProductFlags_name, ProductFlags_value)
	proto.RegisterEnum("Spotify.Platform", Platform_name, Platform_value)
	proto.RegisterEnum("Spotify.Fingerprint", Fingerprint_name, Fingerprint_value)
	proto.RegisterEnum("Spotify.Cryptosuite", Cryptosuite_name, Cryptosuite_value)
	proto.RegisterEnum("Spotify.Powscheme", Powscheme_name, Powscheme_value)
	proto.RegisterEnum("Spotify.ErrorCode", ErrorCode_name, ErrorCode_value)
}

func init() { proto.RegisterFile("keyexchange.proto", fileDescriptor4) }

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