proto.pb.go

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

/*
Package dht is a generated protocol buffer package.

It is generated from these files:
	proto.proto

It has these top-level messages:
	PacketContact
	PacketHeader
	Packet
	PartHeader
	Found
	FoundNodes
	Store
	Broadcast
	Custom
	CustomAnswer
	RepeatPlease
*/
package dht

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

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

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

type Command int32

const (
	Command_NOOP          Command = 0
	Command_PING          Command = 1
	Command_PONG          Command = 2
	Command_STORE         Command = 3
	Command_STORED        Command = 4
	Command_FETCH         Command = 5
	Command_FETCH_NODES   Command = 6
	Command_FOUND         Command = 7
	Command_FOUND_NODES   Command = 8
	Command_BROADCAST     Command = 9
	Command_CUSTOM        Command = 10
	Command_CUSTOM_ANSWER Command = 11
	Command_REPEAT_PLEASE Command = 12
)

var Command_name = map[int32]string{
	0:  "NOOP",
	1:  "PING",
	2:  "PONG",
	3:  "STORE",
	4:  "STORED",
	5:  "FETCH",
	6:  "FETCH_NODES",
	7:  "FOUND",
	8:  "FOUND_NODES",
	9:  "BROADCAST",
	10: "CUSTOM",
	11: "CUSTOM_ANSWER",
	12: "REPEAT_PLEASE",
}
var Command_value = map[string]int32{
	"NOOP":          0,
	"PING":          1,
	"PONG":          2,
	"STORE":         3,
	"STORED":        4,
	"FETCH":         5,
	"FETCH_NODES":   6,
	"FOUND":         7,
	"FOUND_NODES":   8,
	"BROADCAST":     9,
	"CUSTOM":        10,
	"CUSTOM_ANSWER": 11,
	"REPEAT_PLEASE": 12,
}

func (x Command) String() string {
	return proto.EnumName(Command_name, int32(x))
}
func (Command) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

type PacketContact struct {
	Hash []byte `protobuf:"bytes,1,opt,name=Hash,json=hash,proto3" json:"Hash,omitempty"`
	Addr string `protobuf:"bytes,2,opt,name=addr" json:"addr,omitempty"`
}

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

func (m *PacketContact) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *PacketContact) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

type PacketHeader struct {
	DateSent    int64          `protobuf:"varint,1,opt,name=DateSent,json=dateSent" json:"DateSent,omitempty"`
	Command     Command        `protobuf:"varint,2,opt,name=Command,json=command,enum=dht.Command" json:"Command,omitempty"`
	Sender      *PacketContact `protobuf:"bytes,3,opt,name=Sender,json=sender" json:"Sender,omitempty"`
	MessageHash []byte         `protobuf:"bytes,4,opt,name=MessageHash,json=messageHash,proto3" json:"MessageHash,omitempty"`
	ResponseTo  []byte         `protobuf:"bytes,5,opt,name=ResponseTo,json=responseTo,proto3" json:"ResponseTo,omitempty"`
	Nonce       int64          `protobuf:"varint,6,opt,name=Nonce,json=nonce" json:"Nonce,omitempty"`
}

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

func (m *PacketHeader) GetDateSent() int64 {
	if m != nil {
		return m.DateSent
	}
	return 0
}

func (m *PacketHeader) GetCommand() Command {
	if m != nil {
		return m.Command
	}
	return Command_NOOP
}

func (m *PacketHeader) GetSender() *PacketContact {
	if m != nil {
		return m.Sender
	}
	return nil
}

func (m *PacketHeader) GetMessageHash() []byte {
	if m != nil {
		return m.MessageHash
	}
	return nil
}

func (m *PacketHeader) GetResponseTo() []byte {
	if m != nil {
		return m.ResponseTo
	}
	return nil
}

func (m *PacketHeader) GetNonce() int64 {
	if m != nil {
		return m.Nonce
	}
	return 0
}

type Packet struct {
	Header *PacketHeader `protobuf:"bytes,1,opt,name=Header,json=header" json:"Header,omitempty"`
	// Types that are valid to be assigned to Data:
	//	*Packet_Hash
	//	*Packet_Ok
	//	*Packet_FoundNodes
	//	*Packet_Found
	//	*Packet_Store
	//	*Packet_Custom
	//	*Packet_CustomAnswer
	//	*Packet_RepeatPlease
	//	*Packet_Broadcast
	Data isPacket_Data `protobuf_oneof:"Data"`
}

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

type isPacket_Data interface {
	isPacket_Data()
}

type Packet_Hash struct {
	Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3,oneof"`
}
type Packet_Ok struct {
	Ok bool `protobuf:"varint,3,opt,name=ok,oneof"`
}
type Packet_FoundNodes struct {
	FoundNodes *FoundNodes `protobuf:"bytes,6,opt,name=foundNodes,oneof"`
}
type Packet_Found struct {
	Found *Found `protobuf:"bytes,7,opt,name=found,oneof"`
}
type Packet_Store struct {
	Store *Store `protobuf:"bytes,8,opt,name=store,oneof"`
}
type Packet_Custom struct {
	Custom *Custom `protobuf:"bytes,10,opt,name=custom,oneof"`
}
type Packet_CustomAnswer struct {
	CustomAnswer *CustomAnswer `protobuf:"bytes,11,opt,name=customAnswer,oneof"`
}
type Packet_RepeatPlease struct {
	RepeatPlease *RepeatPlease `protobuf:"bytes,12,opt,name=repeatPlease,oneof"`
}
type Packet_Broadcast struct {
	Broadcast *Broadcast `protobuf:"bytes,13,opt,name=broadcast,oneof"`
}

func (*Packet_Hash) isPacket_Data()         {}
func (*Packet_Ok) isPacket_Data()           {}
func (*Packet_FoundNodes) isPacket_Data()   {}
func (*Packet_Found) isPacket_Data()        {}
func (*Packet_Store) isPacket_Data()        {}
func (*Packet_Custom) isPacket_Data()       {}
func (*Packet_CustomAnswer) isPacket_Data() {}
func (*Packet_RepeatPlease) isPacket_Data() {}
func (*Packet_Broadcast) isPacket_Data()    {}

func (m *Packet) GetData() isPacket_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Packet) GetHeader() *PacketHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *Packet) GetHash() []byte {
	if x, ok := m.GetData().(*Packet_Hash); ok {
		return x.Hash
	}
	return nil
}

func (m *Packet) GetOk() bool {
	if x, ok := m.GetData().(*Packet_Ok); ok {
		return x.Ok
	}
	return false
}

func (m *Packet) GetFoundNodes() *FoundNodes {
	if x, ok := m.GetData().(*Packet_FoundNodes); ok {
		return x.FoundNodes
	}
	return nil
}

func (m *Packet) GetFound() *Found {
	if x, ok := m.GetData().(*Packet_Found); ok {
		return x.Found
	}
	return nil
}

func (m *Packet) GetStore() *Store {
	if x, ok := m.GetData().(*Packet_Store); ok {
		return x.Store
	}
	return nil
}

func (m *Packet) GetCustom() *Custom {
	if x, ok := m.GetData().(*Packet_Custom); ok {
		return x.Custom
	}
	return nil
}

func (m *Packet) GetCustomAnswer() *CustomAnswer {
	if x, ok := m.GetData().(*Packet_CustomAnswer); ok {
		return x.CustomAnswer
	}
	return nil
}

func (m *Packet) GetRepeatPlease() *RepeatPlease {
	if x, ok := m.GetData().(*Packet_RepeatPlease); ok {
		return x.RepeatPlease
	}
	return nil
}

func (m *Packet) GetBroadcast() *Broadcast {
	if x, ok := m.GetData().(*Packet_Broadcast); ok {
		return x.Broadcast
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Packet) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Packet_OneofMarshaler, _Packet_OneofUnmarshaler, _Packet_OneofSizer, []interface{}{
		(*Packet_Hash)(nil),
		(*Packet_Ok)(nil),
		(*Packet_FoundNodes)(nil),
		(*Packet_Found)(nil),
		(*Packet_Store)(nil),
		(*Packet_Custom)(nil),
		(*Packet_CustomAnswer)(nil),
		(*Packet_RepeatPlease)(nil),
		(*Packet_Broadcast)(nil),
	}
}

func _Packet_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Packet)
	// Data
	switch x := m.Data.(type) {
	case *Packet_Hash:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeRawBytes(x.Hash)
	case *Packet_Ok:
		t := uint64(0)
		if x.Ok {
			t = 1
		}
		b.EncodeVarint(3<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *Packet_FoundNodes:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.FoundNodes); err != nil {
			return err
		}
	case *Packet_Found:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Found); err != nil {
			return err
		}
	case *Packet_Store:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Store); err != nil {
			return err
		}
	case *Packet_Custom:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Custom); err != nil {
			return err
		}
	case *Packet_CustomAnswer:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CustomAnswer); err != nil {
			return err
		}
	case *Packet_RepeatPlease:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RepeatPlease); err != nil {
			return err
		}
	case *Packet_Broadcast:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Broadcast); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Packet.Data has unexpected type %T", x)
	}
	return nil
}

func _Packet_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Packet)
	switch tag {
	case 2: // Data.hash
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.Data = &Packet_Hash{x}
		return true, err
	case 3: // Data.ok
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Data = &Packet_Ok{x != 0}
		return true, err
	case 6: // Data.foundNodes
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(FoundNodes)
		err := b.DecodeMessage(msg)
		m.Data = &Packet_FoundNodes{msg}
		return true, err
	case 7: // Data.found
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Found)
		err := b.DecodeMessage(msg)
		m.Data = &Packet_Found{msg}
		return true, err
	case 8: // Data.store
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Store)
		err := b.DecodeMessage(msg)
		m.Data = &Packet_Store{msg}
		return true, err
	case 10: // Data.custom
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Custom)
		err := b.DecodeMessage(msg)
		m.Data = &Packet_Custom{msg}
		return true, err
	case 11: // Data.customAnswer
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CustomAnswer)
		err := b.DecodeMessage(msg)
		m.Data = &Packet_CustomAnswer{msg}
		return true, err
	case 12: // Data.repeatPlease
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RepeatPlease)
		err := b.DecodeMessage(msg)
		m.Data = &Packet_RepeatPlease{msg}
		return true, err
	case 13: // Data.broadcast
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Broadcast)
		err := b.DecodeMessage(msg)
		m.Data = &Packet_Broadcast{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Packet_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Packet)
	// Data
	switch x := m.Data.(type) {
	case *Packet_Hash:
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(len(x.Hash)))
		n += len(x.Hash)
	case *Packet_Ok:
		n += proto.SizeVarint(3<<3 | proto.WireVarint)
		n += 1
	case *Packet_FoundNodes:
		s := proto.Size(x.FoundNodes)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Packet_Found:
		s := proto.Size(x.Found)
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Packet_Store:
		s := proto.Size(x.Store)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Packet_Custom:
		s := proto.Size(x.Custom)
		n += proto.SizeVarint(10<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Packet_CustomAnswer:
		s := proto.Size(x.CustomAnswer)
		n += proto.SizeVarint(11<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Packet_RepeatPlease:
		s := proto.Size(x.RepeatPlease)
		n += proto.SizeVarint(12<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Packet_Broadcast:
		s := proto.Size(x.Broadcast)
		n += proto.SizeVarint(13<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type PartHeader struct {
	Id    int32  `protobuf:"varint,1,opt,name=Id,json=id" json:"Id,omitempty"`
	Total int32  `protobuf:"varint,2,opt,name=Total,json=total" json:"Total,omitempty"`
	Hash  []byte `protobuf:"bytes,3,opt,name=Hash,json=hash,proto3" json:"Hash,omitempty"`
	Data  []byte `protobuf:"bytes,4,opt,name=Data,json=data,proto3" json:"Data,omitempty"`
}

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

func (m *PartHeader) GetId() int32 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *PartHeader) GetTotal() int32 {
	if m != nil {
		return m.Total
	}
	return 0
}

func (m *PartHeader) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *PartHeader) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type Found struct {
	Header *PartHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}

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

func (m *Found) GetHeader() *PartHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

type FoundNodes struct {
	Nodes []*PacketContact `protobuf:"bytes,1,rep,name=Nodes,json=nodes" json:"Nodes,omitempty"`
}

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

func (m *FoundNodes) GetNodes() []*PacketContact {
	if m != nil {
		return m.Nodes
	}
	return nil
}

type Store struct {
	Header *PartHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
}

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

func (m *Store) GetHeader() *PartHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

type Broadcast struct {
	Data []byte `protobuf:"bytes,2,opt,name=Data,json=data,proto3" json:"Data,omitempty"`
}

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

func (m *Broadcast) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type Custom struct {
	Command Command `protobuf:"varint,1,opt,name=Command,json=command,enum=dht.Command" json:"Command,omitempty"`
	Data    []byte  `protobuf:"bytes,2,opt,name=Data,json=data,proto3" json:"Data,omitempty"`
}

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

func (m *Custom) GetCommand() Command {
	if m != nil {
		return m.Command
	}
	return Command_NOOP
}

func (m *Custom) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type CustomAnswer struct {
	Data []byte `protobuf:"bytes,2,opt,name=Data,json=data,proto3" json:"Data,omitempty"`
}

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

func (m *CustomAnswer) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type RepeatPlease struct {
	Hash []byte  `protobuf:"bytes,1,opt,name=Hash,json=hash,proto3" json:"Hash,omitempty"`
	Data []int32 `protobuf:"varint,2,rep,packed,name=Data,json=data" json:"Data,omitempty"`
}

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

func (m *RepeatPlease) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *RepeatPlease) GetData() []int32 {
	if m != nil {
		return m.Data
	}
	return nil
}

func init() {
	proto.RegisterType((*PacketContact)(nil), "dht.PacketContact")
	proto.RegisterType((*PacketHeader)(nil), "dht.PacketHeader")
	proto.RegisterType((*Packet)(nil), "dht.Packet")
	proto.RegisterType((*PartHeader)(nil), "dht.PartHeader")
	proto.RegisterType((*Found)(nil), "dht.Found")
	proto.RegisterType((*FoundNodes)(nil), "dht.FoundNodes")
	proto.RegisterType((*Store)(nil), "dht.Store")
	proto.RegisterType((*Broadcast)(nil), "dht.Broadcast")
	proto.RegisterType((*Custom)(nil), "dht.Custom")
	proto.RegisterType((*CustomAnswer)(nil), "dht.CustomAnswer")
	proto.RegisterType((*RepeatPlease)(nil), "dht.RepeatPlease")
	proto.RegisterEnum("dht.Command", Command_name, Command_value)
}

func init() { proto.RegisterFile("proto.proto", fileDescriptor0) }

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